diff --git a/ErsatzTV.Application/Artists/ArtistViewModel.cs b/ErsatzTV.Application/Artists/ArtistViewModel.cs
index 0b37fc210..5b1bb8b4c 100644
--- a/ErsatzTV.Application/Artists/ArtistViewModel.cs
+++ b/ErsatzTV.Application/Artists/ArtistViewModel.cs
@@ -1,16 +1,14 @@
-using System.Collections.Generic;
-using System.Globalization;
+using System.Globalization;
 
-namespace ErsatzTV.Application.Artists
-{
-    public record ArtistViewModel(
-        string Name,
-        string Disambiguation,
-        string Biography,
-        string Thumbnail,
-        string FanArt,
-        List<string> Genres,
-        List<string> Styles,
-        List<string> Moods,
-        List<CultureInfo> Languages);
-}
+namespace ErsatzTV.Application.Artists;
+
+public record ArtistViewModel(
+    string Name,
+    string Disambiguation,
+    string Biography,
+    string Thumbnail,
+    string FanArt,
+    List<string> Genres,
+    List<string> Styles,
+    List<string> Moods,
+    List<CultureInfo> Languages);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Artists/Mapper.cs b/ErsatzTV.Application/Artists/Mapper.cs
index 45f635c49..34fc5d5c9 100644
--- a/ErsatzTV.Application/Artists/Mapper.cs
+++ b/ErsatzTV.Application/Artists/Mapper.cs
@@ -1,46 +1,40 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Artists
+namespace ErsatzTV.Application.Artists;
+
+internal static class Mapper
 {
-    internal static class Mapper
+    internal static ArtistViewModel ProjectToViewModel(Artist artist, List<string> languages)
     {
-        internal static ArtistViewModel ProjectToViewModel(Artist artist, List<string> languages)
-        {
-            ArtistMetadata metadata = Optional(artist.ArtistMetadata).Flatten().Head();
-            return new ArtistViewModel(
-                metadata.Title,
-                metadata.Disambiguation,
-                metadata.Biography,
-                Artwork(metadata, ArtworkKind.Thumbnail),
-                Artwork(metadata, ArtworkKind.FanArt),
-                metadata.Genres.Map(g => g.Name).ToList(),
-                metadata.Styles.Map(s => s.Name).ToList(),
-                metadata.Moods.Map(m => m.Name).ToList(),
-                LanguagesForArtist(languages));
-        }
-
-        private static string Artwork(Metadata metadata, ArtworkKind artworkKind) =>
-            Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
-                .Match(a => a.Path, string.Empty);
-
-        private static List<CultureInfo> LanguagesForArtist(List<string> languages)
-        {
-            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
-
-            return languages
-                .Distinct()
-                .Map(
-                    lang => allCultures.Filter(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
-                .Sequence()
-                .Flatten()
-                .ToList();
-        }
+        ArtistMetadata metadata = Optional(artist.ArtistMetadata).Flatten().Head();
+        return new ArtistViewModel(
+            metadata.Title,
+            metadata.Disambiguation,
+            metadata.Biography,
+            Artwork(metadata, ArtworkKind.Thumbnail),
+            Artwork(metadata, ArtworkKind.FanArt),
+            metadata.Genres.Map(g => g.Name).ToList(),
+            metadata.Styles.Map(s => s.Name).ToList(),
+            metadata.Moods.Map(m => m.Name).ToList(),
+            LanguagesForArtist(languages));
     }
-}
+
+    private static string Artwork(Metadata metadata, ArtworkKind artworkKind) =>
+        Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
+            .Match(a => a.Path, string.Empty);
+
+    private static List<CultureInfo> LanguagesForArtist(List<string> languages)
+    {
+        CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+
+        return languages
+            .Distinct()
+            .Map(
+                lang => allCultures.Filter(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+            .Sequence()
+            .Flatten()
+            .ToList();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Artists/Queries/GetAllArtists.cs b/ErsatzTV.Application/Artists/Queries/GetAllArtists.cs
index b58873fa8..a63d932de 100644
--- a/ErsatzTV.Application/Artists/Queries/GetAllArtists.cs
+++ b/ErsatzTV.Application/Artists/Queries/GetAllArtists.cs
@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using ErsatzTV.Application.MediaItems;
-using MediatR;
+using ErsatzTV.Application.MediaItems;
 
-namespace ErsatzTV.Application.Artists.Queries
-{
-    public record GetAllArtists : IRequest<List<NamedMediaItemViewModel>>;
-}
+namespace ErsatzTV.Application.Artists;
+
+public record GetAllArtists : IRequest<List<NamedMediaItemViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs b/ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs
index d059c08d3..39a0150be 100644
--- a/ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs
+++ b/ErsatzTV.Application/Artists/Queries/GetAllArtistsHandler.cs
@@ -1,29 +1,22 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaItems.Mapper;
 
-namespace ErsatzTV.Application.Artists.Queries
+namespace ErsatzTV.Application.Artists;
+
+public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
 {
-    public class GetAllArtistsHandler : IRequestHandler<GetAllArtists, List<NamedMediaItemViewModel>>
-    {
-        private readonly IArtistRepository _artistRepository;
+    private readonly IArtistRepository _artistRepository;
 
-        public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
+    public GetAllArtistsHandler(IArtistRepository artistRepository) => _artistRepository = artistRepository;
 
-        public Task<List<NamedMediaItemViewModel>> Handle(
-            GetAllArtists request,
-            CancellationToken cancellationToken) =>
-            _artistRepository.GetAllArtists()
-                .Map(
-                    list => list.Filter(
-                        a => !string.IsNullOrWhiteSpace(
-                            a.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => string.Empty))))
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<NamedMediaItemViewModel>> Handle(
+        GetAllArtists request,
+        CancellationToken cancellationToken) =>
+        _artistRepository.GetAllArtists()
+            .Map(
+                list => list.Filter(
+                    a => !string.IsNullOrWhiteSpace(
+                        a.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => string.Empty))))
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Artists/Queries/GetArtistById.cs b/ErsatzTV.Application/Artists/Queries/GetArtistById.cs
index 67d15dd6e..54c8e3642 100644
--- a/ErsatzTV.Application/Artists/Queries/GetArtistById.cs
+++ b/ErsatzTV.Application/Artists/Queries/GetArtistById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Artists;
 
-namespace ErsatzTV.Application.Artists.Queries
-{
-    public record GetArtistById(int ArtistId) : IRequest<Option<ArtistViewModel>>;
-}
+public record GetArtistById(int ArtistId) : IRequest<Option<ArtistViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs b/ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs
index dc676992b..e4e8304c6 100644
--- a/ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs
+++ b/ErsatzTV.Application/Artists/Queries/GetArtistByIdHandler.cs
@@ -1,38 +1,32 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.Artists.Mapper;
 
-namespace ErsatzTV.Application.Artists.Queries
+namespace ErsatzTV.Application.Artists;
+
+public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<ArtistViewModel>>
 {
-    public class GetArtistByIdHandler : IRequestHandler<GetArtistById, Option<ArtistViewModel>>
+    private readonly IArtistRepository _artistRepository;
+    private readonly ISearchRepository _searchRepository;
+
+    public GetArtistByIdHandler(IArtistRepository artistRepository, ISearchRepository searchRepository)
     {
-        private readonly IArtistRepository _artistRepository;
-        private readonly ISearchRepository _searchRepository;
-
-        public GetArtistByIdHandler(IArtistRepository artistRepository, ISearchRepository searchRepository)
-        {
-            _artistRepository = artistRepository;
-            _searchRepository = searchRepository;
-        }
-
-        public async Task<Option<ArtistViewModel>> Handle(
-            GetArtistById request,
-            CancellationToken cancellationToken)
-        {
-            Option<Artist> maybeArtist = await _artistRepository.GetArtist(request.ArtistId);
-            return await maybeArtist.Match<Task<Option<ArtistViewModel>>>(
-                async artist =>
-                {
-                    List<string> mediaCodes = await _searchRepository.GetLanguagesForArtist(artist);
-                    List<string> languageCodes = await _searchRepository.GetAllLanguageCodes(mediaCodes);
-                    return ProjectToViewModel(artist, languageCodes);
-                },
-                () => Task.FromResult(Option<ArtistViewModel>.None));
-        }
+        _artistRepository = artistRepository;
+        _searchRepository = searchRepository;
     }
-}
+
+    public async Task<Option<ArtistViewModel>> Handle(
+        GetArtistById request,
+        CancellationToken cancellationToken)
+    {
+        Option<Artist> maybeArtist = await _artistRepository.GetArtist(request.ArtistId);
+        return await maybeArtist.Match<Task<Option<ArtistViewModel>>>(
+            async artist =>
+            {
+                List<string> mediaCodes = await _searchRepository.GetLanguagesForArtist(artist);
+                List<string> languageCodes = await _searchRepository.GetAllLanguageCodes(mediaCodes);
+                return ProjectToViewModel(artist, languageCodes);
+            },
+            () => Task.FromResult(Option<ArtistViewModel>.None));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/ChannelViewModel.cs b/ErsatzTV.Application/Channels/ChannelViewModel.cs
index 4a33115ca..04b846b21 100644
--- a/ErsatzTV.Application/Channels/ChannelViewModel.cs
+++ b/ErsatzTV.Application/Channels/ChannelViewModel.cs
@@ -1,18 +1,17 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Channels
-{
-    public record ChannelViewModel(
-        int Id,
-        string Number,
-        string Name,
-        string Group,
-        string Categories,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId,
-        int? FallbackFillerId,
-        int PlayoutCount);
-}
+namespace ErsatzTV.Application.Channels;
+
+public record ChannelViewModel(
+    int Id,
+    string Number,
+    string Name,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    string Logo,
+    string PreferredLanguageCode,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId,
+    int PlayoutCount);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Commands/CreateChannel.cs b/ErsatzTV.Application/Channels/Commands/CreateChannel.cs
index 033e3e52a..fbfdf75db 100644
--- a/ErsatzTV.Application/Channels/Commands/CreateChannel.cs
+++ b/ErsatzTV.Application/Channels/Commands/CreateChannel.cs
@@ -1,20 +1,17 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record CreateChannel
-    (
-        string Name,
-        string Number,
-        string Group,
-        string Categories,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId,
-        int? FallbackFillerId) : IRequest<Either<BaseError, CreateChannelResult>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record CreateChannel
+(
+    string Name,
+    string Number,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    string Logo,
+    string PreferredLanguageCode,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId) : IRequest<Either<BaseError, CreateChannelResult>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs b/ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs
index bd16ff008..a0cbc5caa 100644
--- a/ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs
+++ b/ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs
@@ -1,164 +1,155 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
 {
-    public class CreateChannelHandler : IRequestHandler<CreateChannel, Either<BaseError, CreateChannelResult>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, CreateChannelResult>> Handle(
+        CreateChannel request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) => _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, CreateChannelResult>> Handle(
-            CreateChannel request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => PersistChannel(dbContext, c));
-        }
-
-        private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
-        {
-            await dbContext.Channels.AddAsync(channel);
-            await dbContext.SaveChangesAsync();
-            return new CreateChannelResult(channel.Id);
-        }
-
-        private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
-            (ValidateName(request), await ValidateNumber(dbContext, request),
-                await FFmpegProfileMustExist(dbContext, request),
-                ValidatePreferredLanguage(request),
-                await WatermarkMustExist(dbContext, request),
-                await FillerPresetMustExist(dbContext, request))
-            .Apply(
-                (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId, fillerPresetId) =>
-                {
-                    var artwork = new List<Artwork>();
-                    if (!string.IsNullOrWhiteSpace(request.Logo))
-                    {
-                        artwork.Add(
-                            new Artwork
-                            {
-                                Path = request.Logo,
-                                ArtworkKind = ArtworkKind.Logo,
-                                DateAdded = DateTime.UtcNow,
-                                DateUpdated = DateTime.UtcNow
-                            });
-                    }
-
-                    var channel = new Channel(Guid.NewGuid())
-                    {
-                        Name = name,
-                        Number = number,
-                        Group = request.Group,
-                        Categories = request.Categories,
-                        FFmpegProfileId = ffmpegProfileId,
-                        StreamingMode = request.StreamingMode,
-                        Artwork = artwork,
-                        PreferredLanguageCode = preferredLanguageCode
-                    };
-
-                    foreach (int id in watermarkId)
-                    {
-                        channel.WatermarkId = id;
-                    }
-
-                    foreach (int id in fillerPresetId)
-                    {
-                        channel.FallbackFillerId = id;
-                    }
-
-                    return channel;
-                });
-
-        private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
-            createChannel.NotEmpty(c => c.Name)
-                .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
-
-        private static Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
-            Optional(createChannel.PreferredLanguageCode ?? string.Empty)
-                .Filter(
-                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-                .ToValidation<BaseError>("Preferred language code is invalid");
-
-        private static async Task<Validation<BaseError, string>> ValidateNumber(TvContext dbContext, CreateChannel createChannel)
-        {
-            Option<Channel> maybeExistingChannel = await dbContext.Channels
-                .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number);
-            return maybeExistingChannel.Match<Validation<BaseError, string>>(
-                _ => BaseError.New("Channel number must be unique"),
-                () =>
-                {
-                    if (Regex.IsMatch(createChannel.Number, Channel.NumberValidator))
-                    {
-                        return createChannel.Number;
-                    }
-
-                    return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
-                });
-        }
-
-        private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
-            TvContext dbContext,
-            CreateChannel createChannel) =>
-            dbContext.FFmpegProfiles
-                .CountAsync(p => p.Id == createChannel.FFmpegProfileId)
-                .Map(Optional)
-                .Filter(c => c > 0)
-                .MapT(_ => createChannel.FFmpegProfileId)
-                .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist."));
-
-        private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
-            TvContext dbContext,
-            CreateChannel createChannel)
-        {
-            if (createChannel.WatermarkId is null)
-            {
-                return Option<int>.None;
-            }
-
-            return await dbContext.ChannelWatermarks
-                .CountAsync(w => w.Id == createChannel.WatermarkId)
-                .Map(Optional)
-                .Filter(c => c > 0)
-                .MapT(_ => Optional(createChannel.WatermarkId))
-                .Map(o => o.ToValidation<BaseError>($"Watermark {createChannel.WatermarkId} does not exist."));
-        }
-
-        private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
-            TvContext dbContext,
-            CreateChannel createChannel)
-        {
-            if (createChannel.FallbackFillerId is null)
-            {
-                return Option<int>.None;
-            }
-
-            return await dbContext.FillerPresets
-                .Filter(fp => fp.FillerKind == FillerKind.Fallback)
-                .CountAsync(w => w.Id == createChannel.FallbackFillerId)
-                .Map(Optional)
-                .Filter(c => c > 0)
-                .MapT(_ => Optional(createChannel.FallbackFillerId))
-                .Map(
-                    o => o.ToValidation<BaseError>(
-                        $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
-        }
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => PersistChannel(dbContext, c));
     }
-}
+
+    private static async Task<CreateChannelResult> PersistChannel(TvContext dbContext, Channel channel)
+    {
+        await dbContext.Channels.AddAsync(channel);
+        await dbContext.SaveChangesAsync();
+        return new CreateChannelResult(channel.Id);
+    }
+
+    private static async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, CreateChannel request) =>
+        (ValidateName(request), await ValidateNumber(dbContext, request),
+            await FFmpegProfileMustExist(dbContext, request),
+            ValidatePreferredLanguage(request),
+            await WatermarkMustExist(dbContext, request),
+            await FillerPresetMustExist(dbContext, request))
+        .Apply(
+            (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId, fillerPresetId) =>
+            {
+                var artwork = new List<Artwork>();
+                if (!string.IsNullOrWhiteSpace(request.Logo))
+                {
+                    artwork.Add(
+                        new Artwork
+                        {
+                            Path = request.Logo,
+                            ArtworkKind = ArtworkKind.Logo,
+                            DateAdded = DateTime.UtcNow,
+                            DateUpdated = DateTime.UtcNow
+                        });
+                }
+
+                var channel = new Channel(Guid.NewGuid())
+                {
+                    Name = name,
+                    Number = number,
+                    Group = request.Group,
+                    Categories = request.Categories,
+                    FFmpegProfileId = ffmpegProfileId,
+                    StreamingMode = request.StreamingMode,
+                    Artwork = artwork,
+                    PreferredLanguageCode = preferredLanguageCode
+                };
+
+                foreach (int id in watermarkId)
+                {
+                    channel.WatermarkId = id;
+                }
+
+                foreach (int id in fillerPresetId)
+                {
+                    channel.FallbackFillerId = id;
+                }
+
+                return channel;
+            });
+
+    private static Validation<BaseError, string> ValidateName(CreateChannel createChannel) =>
+        createChannel.NotEmpty(c => c.Name)
+            .Bind(_ => createChannel.NotLongerThan(50)(c => c.Name));
+
+    private static Validation<BaseError, string> ValidatePreferredLanguage(CreateChannel createChannel) =>
+        Optional(createChannel.PreferredLanguageCode ?? string.Empty)
+            .Filter(
+                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+            .ToValidation<BaseError>("Preferred language code is invalid");
+
+    private static async Task<Validation<BaseError, string>> ValidateNumber(TvContext dbContext, CreateChannel createChannel)
+    {
+        Option<Channel> maybeExistingChannel = await dbContext.Channels
+            .SelectOneAsync(c => c.Number, c => c.Number == createChannel.Number);
+        return maybeExistingChannel.Match<Validation<BaseError, string>>(
+            _ => BaseError.New("Channel number must be unique"),
+            () =>
+            {
+                if (Regex.IsMatch(createChannel.Number, Channel.NumberValidator))
+                {
+                    return createChannel.Number;
+                }
+
+                return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
+            });
+    }
+
+    private static Task<Validation<BaseError, int>> FFmpegProfileMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel) =>
+        dbContext.FFmpegProfiles
+            .CountAsync(p => p.Id == createChannel.FFmpegProfileId)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => createChannel.FFmpegProfileId)
+            .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {createChannel.FFmpegProfileId} does not exist."));
+
+    private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel)
+    {
+        if (createChannel.WatermarkId is null)
+        {
+            return Option<int>.None;
+        }
+
+        return await dbContext.ChannelWatermarks
+            .CountAsync(w => w.Id == createChannel.WatermarkId)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => Optional(createChannel.WatermarkId))
+            .Map(o => o.ToValidation<BaseError>($"Watermark {createChannel.WatermarkId} does not exist."));
+    }
+
+    private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
+        TvContext dbContext,
+        CreateChannel createChannel)
+    {
+        if (createChannel.FallbackFillerId is null)
+        {
+            return Option<int>.None;
+        }
+
+        return await dbContext.FillerPresets
+            .Filter(fp => fp.FillerKind == FillerKind.Fallback)
+            .CountAsync(w => w.Id == createChannel.FallbackFillerId)
+            .Map(Optional)
+            .Filter(c => c > 0)
+            .MapT(_ => Optional(createChannel.FallbackFillerId))
+            .Map(
+                o => o.ToValidation<BaseError>(
+                    $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Commands/CreateChannelResult.cs b/ErsatzTV.Application/Channels/Commands/CreateChannelResult.cs
index ccd147197..af9178516 100644
--- a/ErsatzTV.Application/Channels/Commands/CreateChannelResult.cs
+++ b/ErsatzTV.Application/Channels/Commands/CreateChannelResult.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record CreateChannelResult(int ChannelId) : EntityIdResult(ChannelId);
-}
+namespace ErsatzTV.Application.Channels;
+
+public record CreateChannelResult(int ChannelId) : EntityIdResult(ChannelId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Commands/DeleteChannel.cs b/ErsatzTV.Application/Channels/Commands/DeleteChannel.cs
index 76fd60299..14f6365b6 100644
--- a/ErsatzTV.Application/Channels/Commands/DeleteChannel.cs
+++ b/ErsatzTV.Application/Channels/Commands/DeleteChannel.cs
@@ -1,9 +1,5 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Task>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record DeleteChannel(int ChannelId) : IRequest<Either<BaseError, Task>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs b/ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs
index 83b019d7d..b6534cf27 100644
--- a/ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs
+++ b/ErsatzTV.Application/Channels/Commands/DeleteChannelHandler.cs
@@ -1,28 +1,23 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Task>>
 {
-    public class DeleteChannelHandler : IRequestHandler<DeleteChannel, Either<BaseError, Task>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public DeleteChannelHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public DeleteChannelHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public async Task<Either<BaseError, Task>> Handle(DeleteChannel request, CancellationToken cancellationToken) =>
-            (await ChannelMustExist(request))
-            .Map(DoDeletion)
-            .ToEither<Task>();
+    public async Task<Either<BaseError, Task>> Handle(DeleteChannel request, CancellationToken cancellationToken) =>
+        (await ChannelMustExist(request))
+        .Map(DoDeletion)
+        .ToEither<Task>();
 
-        private Task DoDeletion(int channelId) => _channelRepository.Delete(channelId);
+    private Task DoDeletion(int channelId) => _channelRepository.Delete(channelId);
 
-        private async Task<Validation<BaseError, int>> ChannelMustExist(DeleteChannel deleteChannel) =>
-            (await _channelRepository.Get(deleteChannel.ChannelId))
-            .ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.")
-            .Map(c => c.Id);
-    }
-}
+    private async Task<Validation<BaseError, int>> ChannelMustExist(DeleteChannel deleteChannel) =>
+        (await _channelRepository.Get(deleteChannel.ChannelId))
+        .ToValidation<BaseError>($"Channel {deleteChannel.ChannelId} does not exist.")
+        .Map(c => c.Id);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Commands/UpdateChannel.cs b/ErsatzTV.Application/Channels/Commands/UpdateChannel.cs
index d4ac52093..fed79c254 100644
--- a/ErsatzTV.Application/Channels/Commands/UpdateChannel.cs
+++ b/ErsatzTV.Application/Channels/Commands/UpdateChannel.cs
@@ -1,21 +1,18 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Commands
-{
-    public record UpdateChannel
-    (
-        int ChannelId,
-        string Name,
-        string Number,
-        string Group,
-        string Categories,
-        int FFmpegProfileId,
-        string Logo,
-        string PreferredLanguageCode,
-        StreamingMode StreamingMode,
-        int? WatermarkId,
-        int? FallbackFillerId) : IRequest<Either<BaseError, ChannelViewModel>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record UpdateChannel
+(
+    int ChannelId,
+    string Name,
+    string Number,
+    string Group,
+    string Categories,
+    int FFmpegProfileId,
+    string Logo,
+    string PreferredLanguageCode,
+    StreamingMode StreamingMode,
+    int? WatermarkId,
+    int? FallbackFillerId) : IRequest<Either<BaseError, ChannelViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs b/ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs
index 5aee3c713..e2052b9e7 100644
--- a/ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs
+++ b/ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs
@@ -1,124 +1,115 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Channels.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels.Commands
+namespace ErsatzTV.Application.Channels;
+
+public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
 {
-    public class UpdateChannelHandler : IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, ChannelViewModel>> Handle(
+        UpdateChannel request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdateChannelHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, ChannelViewModel>> Handle(
-            UpdateChannel request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            Validation<BaseError, Channel> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
-        }
-
-        private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
-        {
-            c.Name = update.Name;
-            c.Number = update.Number;
-            c.Group = update.Group;
-            c.Categories = update.Categories;
-            c.FFmpegProfileId = update.FFmpegProfileId;
-            c.PreferredLanguageCode = update.PreferredLanguageCode;
-            c.Artwork ??= new List<Artwork>();
-
-            if (!string.IsNullOrWhiteSpace(update.Logo))
-            {
-                Option<Artwork> maybeLogo =
-                    Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
-
-                maybeLogo.Match(
-                    artwork =>
-                    {
-                        artwork.Path = update.Logo;
-                        artwork.DateUpdated = DateTime.UtcNow;
-                    },
-                    () =>
-                    {
-                        var artwork = new Artwork
-                        {
-                            Path = update.Logo,
-                            DateAdded = DateTime.UtcNow,
-                            DateUpdated = DateTime.UtcNow,
-                            ArtworkKind = ArtworkKind.Logo
-                        };
-                        c.Artwork.Add(artwork);
-                    });
-            }
-            
-            c.StreamingMode = update.StreamingMode;
-            c.WatermarkId = update.WatermarkId;
-            c.FallbackFillerId = update.FallbackFillerId;
-            await dbContext.SaveChangesAsync();
-            return ProjectToViewModel(c);
-        }
-
-        private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
-            (await ChannelMustExist(dbContext, request), ValidateName(request),
-                await ValidateNumber(dbContext, request),
-                ValidatePreferredLanguage(request))
-            .Apply((channelToUpdate, _, _, _) => channelToUpdate);
-
-        private static Task<Validation<BaseError, Channel>> ChannelMustExist(
-            TvContext dbContext,
-            UpdateChannel updateChannel) =>
-            dbContext.Channels
-                .Include(c => c.Artwork)
-                .Include(c => c.Watermark)
-                .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
-                .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
-
-        private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
-            updateChannel.NotEmpty(c => c.Name)
-                .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
-
-        private static async Task<Validation<BaseError, string>> ValidateNumber(
-            TvContext dbContext,
-            UpdateChannel updateChannel)
-        {
-            int matchId = await dbContext.Channels
-                .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
-                .Match(c => c.Id, () => updateChannel.ChannelId);
-
-            if (matchId == updateChannel.ChannelId)
-            {
-                if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
-                {
-                    return updateChannel.Number;
-                }
-
-                return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
-            }
-
-            return BaseError.New("Channel number must be unique");
-        }
-
-        private static Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
-            Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
-                .Filter(
-                    lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
-                .ToValidation<BaseError>("Preferred language code is invalid");
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Channel> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
     }
-}
+
+    private async Task<ChannelViewModel> ApplyUpdateRequest(TvContext dbContext, Channel c, UpdateChannel update)
+    {
+        c.Name = update.Name;
+        c.Number = update.Number;
+        c.Group = update.Group;
+        c.Categories = update.Categories;
+        c.FFmpegProfileId = update.FFmpegProfileId;
+        c.PreferredLanguageCode = update.PreferredLanguageCode;
+        c.Artwork ??= new List<Artwork>();
+
+        if (!string.IsNullOrWhiteSpace(update.Logo))
+        {
+            Option<Artwork> maybeLogo =
+                Optional(c.Artwork).Flatten().FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo);
+
+            maybeLogo.Match(
+                artwork =>
+                {
+                    artwork.Path = update.Logo;
+                    artwork.DateUpdated = DateTime.UtcNow;
+                },
+                () =>
+                {
+                    var artwork = new Artwork
+                    {
+                        Path = update.Logo,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = DateTime.UtcNow,
+                        ArtworkKind = ArtworkKind.Logo
+                    };
+                    c.Artwork.Add(artwork);
+                });
+        }
+            
+        c.StreamingMode = update.StreamingMode;
+        c.WatermarkId = update.WatermarkId;
+        c.FallbackFillerId = update.FallbackFillerId;
+        await dbContext.SaveChangesAsync();
+        return ProjectToViewModel(c);
+    }
+
+    private async Task<Validation<BaseError, Channel>> Validate(TvContext dbContext, UpdateChannel request) =>
+        (await ChannelMustExist(dbContext, request), ValidateName(request),
+            await ValidateNumber(dbContext, request),
+            ValidatePreferredLanguage(request))
+        .Apply((channelToUpdate, _, _, _) => channelToUpdate);
+
+    private static Task<Validation<BaseError, Channel>> ChannelMustExist(
+        TvContext dbContext,
+        UpdateChannel updateChannel) =>
+        dbContext.Channels
+            .Include(c => c.Artwork)
+            .Include(c => c.Watermark)
+            .SelectOneAsync(c => c.Id, c => c.Id == updateChannel.ChannelId)
+            .Map(o => o.ToValidation<BaseError>("Channel does not exist."));
+
+    private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
+        updateChannel.NotEmpty(c => c.Name)
+            .Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
+
+    private static async Task<Validation<BaseError, string>> ValidateNumber(
+        TvContext dbContext,
+        UpdateChannel updateChannel)
+    {
+        int matchId = await dbContext.Channels
+            .SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number)
+            .Match(c => c.Id, () => updateChannel.ChannelId);
+
+        if (matchId == updateChannel.ChannelId)
+        {
+            if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
+            {
+                return updateChannel.Number;
+            }
+
+            return BaseError.New("Invalid channel number; one decimal is allowed for subchannels");
+        }
+
+        return BaseError.New("Channel number must be unique");
+    }
+
+    private static Validation<BaseError, string> ValidatePreferredLanguage(UpdateChannel updateChannel) =>
+        Optional(updateChannel.PreferredLanguageCode ?? string.Empty)
+            .Filter(
+                lc => string.IsNullOrWhiteSpace(lc) || CultureInfo.GetCultures(CultureTypes.NeutralCultures).Any(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lc, StringComparison.OrdinalIgnoreCase)))
+            .ToValidation<BaseError>("Preferred language code is invalid");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Mapper.cs b/ErsatzTV.Application/Channels/Mapper.cs
index 4024f2e86..b48406ec0 100644
--- a/ErsatzTV.Application/Channels/Mapper.cs
+++ b/ErsatzTV.Application/Channels/Mapper.cs
@@ -1,32 +1,29 @@
-using System.Linq;
-using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Channels
+namespace ErsatzTV.Application.Channels;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
-            new(
-                channel.Id,
-                channel.Number,
-                channel.Name,
-                channel.Group,
-                channel.Categories,
-                channel.FFmpegProfileId,
-                GetLogo(channel),
-                channel.PreferredLanguageCode,
-                channel.StreamingMode,
-                channel.WatermarkId,
-                channel.FallbackFillerId,
-                channel.Playouts?.Count ?? 0);
+    internal static ChannelViewModel ProjectToViewModel(Channel channel) =>
+        new(
+            channel.Id,
+            channel.Number,
+            channel.Name,
+            channel.Group,
+            channel.Categories,
+            channel.FFmpegProfileId,
+            GetLogo(channel),
+            channel.PreferredLanguageCode,
+            channel.StreamingMode,
+            channel.WatermarkId,
+            channel.FallbackFillerId,
+            channel.Playouts?.Count ?? 0);
 
-        private static string GetLogo(Channel channel) =>
-            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
-                .Match(a => a.Path, string.Empty);
+    private static string GetLogo(Channel channel) =>
+        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
+            .Match(a => a.Path, string.Empty);
 
-        private static string GetWatermark(Channel channel) =>
-            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Watermark))
-                .Match(a => a.Path, string.Empty);
-    }
-}
+    private static string GetWatermark(Channel channel) =>
+        Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Watermark))
+            .Match(a => a.Path, string.Empty);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetAllChannels.cs b/ErsatzTV.Application/Channels/Queries/GetAllChannels.cs
index 99c5d0f08..4c05e0f68 100644
--- a/ErsatzTV.Application/Channels/Queries/GetAllChannels.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetAllChannels.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Channels;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetAllChannels : IRequest<List<ChannelViewModel>>;
-}
+public record GetAllChannels : IRequest<List<ChannelViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs b/ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs
index 7d4f8c1f0..87e891013 100644
--- a/ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetAllChannelsHandler.cs
@@ -1,21 +1,14 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Channels.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetAllChannelsHandler : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
 {
-    public class GetAllChannelsHandler : IRequestHandler<GetAllChannels, List<ChannelViewModel>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public GetAllChannelsHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
-            Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
-    }
-}
+    public async Task<List<ChannelViewModel>> Handle(GetAllChannels request, CancellationToken cancellationToken) =>
+        Optional(await _channelRepository.GetAll()).Flatten().Map(ProjectToViewModel).ToList();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelById.cs b/ErsatzTV.Application/Channels/Queries/GetChannelById.cs
index 696ee2e45..af490209a 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelById.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Channels;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetChannelById(int Id) : IRequest<Option<ChannelViewModel>>;
-}
+public record GetChannelById(int Id) : IRequest<Option<ChannelViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs b/ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs
index 8770c9671..07638286a 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelByIdHandler.cs
@@ -1,20 +1,15 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Channels.Mapper;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelByIdHandler : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
 {
-    public class GetChannelByIdHandler : IRequestHandler<GetChannelById, Option<ChannelViewModel>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public GetChannelByIdHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public GetChannelByIdHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public Task<Option<ChannelViewModel>> Handle(GetChannelById request, CancellationToken cancellationToken) =>
-            _channelRepository.Get(request.Id)
-                .MapT(ProjectToViewModel);
-    }
-}
+    public Task<Option<ChannelViewModel>> Handle(GetChannelById request, CancellationToken cancellationToken) =>
+        _channelRepository.Get(request.Id)
+            .MapT(ProjectToViewModel);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs b/ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs
index d2f69d539..7d907e277 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelFramerate.cs
@@ -1,6 +1,3 @@
-using LanguageExt;
-using MediatR;
-
-namespace ErsatzTV.Application.Channels.Queries;
+namespace ErsatzTV.Application.Channels;
 
 public record GetChannelFramerate(string ChannelNumber) : IRequest<Option<int>>;
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs b/ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs
index a68c52019..632bea988 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelFramerateHandler.cs
@@ -1,18 +1,10 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Channels.Queries;
+namespace ErsatzTV.Application.Channels;
 
 public class GetChannelFramerateHandler : IRequestHandler<GetChannelFramerate, Option<int>>
 {
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs b/ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs
index 5d37ca95c..5b097262e 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelGuide.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core.Iptv;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetChannelGuide(string Scheme, string Host) : IRequest<ChannelGuide>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelGuide(string Scheme, string Host) : IRequest<ChannelGuide>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs b/ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs
index 8b07dadd9..378599358 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelGuideHandler.cs
@@ -1,20 +1,15 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Iptv;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGuide>
 {
-    public class GetChannelGuideHandler : IRequestHandler<GetChannelGuide, ChannelGuide>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public GetChannelGuideHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public GetChannelGuideHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAllForGuide()
-                .Map(channels => new ChannelGuide(request.Scheme, request.Host, channels));
-    }
-}
+    public Task<ChannelGuide> Handle(GetChannelGuide request, CancellationToken cancellationToken) =>
+        _channelRepository.GetAllForGuide()
+            .Map(channels => new ChannelGuide(request.Scheme, request.Host, channels));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs b/ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs
index 979522d53..6201557ca 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelLineup.cs
@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Hdhr;
-using MediatR;
+using ErsatzTV.Core.Hdhr;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetChannelLineup(string Scheme, string Host) : IRequest<List<LineupItem>>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelLineup(string Scheme, string Host) : IRequest<List<LineupItem>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs b/ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs
index c43e17c21..214f1c243 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelLineupHandler.cs
@@ -1,22 +1,15 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Hdhr;
+using ErsatzTV.Core.Hdhr;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<LineupItem>>
 {
-    public class GetChannelLineupHandler : IRequestHandler<GetChannelLineup, List<LineupItem>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public GetChannelLineupHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
+    public GetChannelLineupHandler(IChannelRepository channelRepository) => _channelRepository = channelRepository;
 
-        public Task<List<LineupItem>> Handle(GetChannelLineup request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAll()
-                .Map(channels => channels.Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
-    }
-}
+    public Task<List<LineupItem>> Handle(GetChannelLineup request, CancellationToken cancellationToken) =>
+        _channelRepository.GetAll()
+            .Map(channels => channels.Map(c => new LineupItem(request.Scheme, request.Host, c)).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs b/ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs
index f263e7dc2..ab4667909 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelPlaylist.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core.Iptv;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
-{
-    public record GetChannelPlaylist(string Scheme, string Host, string Mode) : IRequest<ChannelPlaylist>;
-}
+namespace ErsatzTV.Application.Channels;
+
+public record GetChannelPlaylist(string Scheme, string Host, string Mode) : IRequest<ChannelPlaylist>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs b/ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs
index 1ae633d4a..66a6576f1 100644
--- a/ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs
@@ -1,56 +1,50 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Iptv;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Channels.Queries
+namespace ErsatzTV.Application.Channels;
+
+public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
 {
-    public class GetChannelPlaylistHandler : IRequestHandler<GetChannelPlaylist, ChannelPlaylist>
+    private readonly IChannelRepository _channelRepository;
+
+    public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
+        _channelRepository = channelRepository;
+
+    public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
+        _channelRepository.GetAll()
+            .Map(channels => EnsureMode(channels, request.Mode))
+            .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, channels));
+
+    private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
     {
-        private readonly IChannelRepository _channelRepository;
-
-        public GetChannelPlaylistHandler(IChannelRepository channelRepository) =>
-            _channelRepository = channelRepository;
-
-        public Task<ChannelPlaylist> Handle(GetChannelPlaylist request, CancellationToken cancellationToken) =>
-            _channelRepository.GetAll()
-                .Map(channels => EnsureMode(channels, request.Mode))
-                .Map(channels => new ChannelPlaylist(request.Scheme, request.Host, channels));
-
-        private static List<Channel> EnsureMode(IEnumerable<Channel> channels, string mode)
+        var result = new List<Channel>();
+        foreach (Channel channel in channels)
         {
-            var result = new List<Channel>();
-            foreach (Channel channel in channels)
+            switch (mode.ToLowerInvariant())
             {
-                switch (mode.ToLowerInvariant())
-                {
-                    case "segmenter":
-                        channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenter;
-                        result.Add(channel);
-                        break;
-                    case "hls-direct":
-                        channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
-                        result.Add(channel);
-                        break;
-                    case "ts-legacy":
-                        channel.StreamingMode = StreamingMode.TransportStream;
-                        result.Add(channel);
-                        break;
-                    case "ts":
-                        channel.StreamingMode = StreamingMode.TransportStreamHybrid;
-                        result.Add(channel);
-                        break;
-                    default:
-                        result.Add(channel);
-                        break;
-                }
+                case "segmenter":
+                    channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenter;
+                    result.Add(channel);
+                    break;
+                case "hls-direct":
+                    channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
+                    result.Add(channel);
+                    break;
+                case "ts-legacy":
+                    channel.StreamingMode = StreamingMode.TransportStream;
+                    result.Add(channel);
+                    break;
+                case "ts":
+                    channel.StreamingMode = StreamingMode.TransportStreamHybrid;
+                    result.Add(channel);
+                    break;
+                default:
+                    result.Add(channel);
+                    break;
             }
-
-            return result;
         }
+
+        return result;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs b/ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs
index 2f814f5c9..3cba41e08 100644
--- a/ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs
+++ b/ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKey.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Configuration.Commands
-{
-    public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : MediatR.IRequest<Unit>;
-}
+namespace ErsatzTV.Application.Configuration;
+
+public record SaveConfigElementByKey(ConfigElementKey Key, string Value) : MediatR.IRequest<Unit>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs b/ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs
index d2bdb4a72..091d197d7 100644
--- a/ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs
+++ b/ErsatzTV.Application/Configuration/Commands/SaveConfigElementByKeyHandler.cs
@@ -1,21 +1,17 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
+using ErsatzTV.Core.Interfaces.Repositories;
 
-namespace ErsatzTV.Application.Configuration.Commands
+namespace ErsatzTV.Application.Configuration;
+
+public class SaveConfigElementByKeyHandler : MediatR.IRequestHandler<SaveConfigElementByKey, Unit>
 {
-    public class SaveConfigElementByKeyHandler : MediatR.IRequestHandler<SaveConfigElementByKey, Unit>
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<Unit> Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-
-        public SaveConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
-
-        public async Task<Unit> Handle(SaveConfigElementByKey request, CancellationToken cancellationToken)
-        {
-            await _configElementRepository.Upsert(request.Key, request.Value);
-            return Unit.Default;
-        }
+        await _configElementRepository.Upsert(request.Key, request.Value);
+        return Unit.Default;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs b/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs
index 4b9a7c012..244b7db80 100644
--- a/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs
+++ b/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshInterval.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Configuration.Commands
-{
-    public record UpdateLibraryRefreshInterval(int LibraryRefreshInterval) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Configuration;
+
+public record UpdateLibraryRefreshInterval(int LibraryRefreshInterval) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs b/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs
index 6e232d98c..66236301d 100644
--- a/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs
+++ b/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs
@@ -1,33 +1,28 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Configuration.Commands
+namespace ErsatzTV.Application.Configuration;
+
+public class UpdateLibraryRefreshIntervalHandler :
+    MediatR.IRequestHandler<UpdateLibraryRefreshInterval, Either<BaseError, Unit>>
 {
-    public class UpdateLibraryRefreshIntervalHandler :
-        MediatR.IRequestHandler<UpdateLibraryRefreshInterval, Either<BaseError, Unit>>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
+    private readonly IConfigElementRepository _configElementRepository;
 
-        public UpdateLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+    public UpdateLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
 
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdateLibraryRefreshInterval request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(_ => _configElementRepository.Upsert(ConfigElementKey.LibraryRefreshInterval, request.LibraryRefreshInterval))
-                .Bind(v => v.ToEitherAsync());
+    public Task<Either<BaseError, Unit>> Handle(
+        UpdateLibraryRefreshInterval request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(_ => _configElementRepository.Upsert(ConfigElementKey.LibraryRefreshInterval, request.LibraryRefreshInterval))
+            .Bind(v => v.ToEitherAsync());
 
-        private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
-            Optional(request.LibraryRefreshInterval)
-                .Where(lri => lri > 0)
-                .Map(_ => Unit.Default)
-                .ToValidation<BaseError>("Tuner count must be greater than zero")
-                .AsTask();
-    }
-}
+    private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
+        Optional(request.LibraryRefreshInterval)
+            .Where(lri => lri > 0)
+            .Map(_ => Unit.Default)
+            .ToValidation<BaseError>("Tuner count must be greater than zero")
+            .AsTask();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs b/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs
index fba7759e5..1c2fe661d 100644
--- a/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs
+++ b/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuild.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Configuration.Commands
-{
-    public record UpdatePlayoutDaysToBuild(int DaysToBuild) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Configuration;
+
+public record UpdatePlayoutDaysToBuild(int DaysToBuild) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs b/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs
index c8a5b90ad..77f205396 100644
--- a/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs
+++ b/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs
@@ -1,66 +1,59 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Configuration.Commands
+namespace ErsatzTV.Application.Configuration;
+
+public class
+    UpdatePlayoutDaysToBuildHandler : MediatR.IRequestHandler<UpdatePlayoutDaysToBuild, Either<BaseError, Unit>>
 {
-    public class
-        UpdatePlayoutDaysToBuildHandler : MediatR.IRequestHandler<UpdatePlayoutDaysToBuild, Either<BaseError, Unit>>
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+
+    public UpdatePlayoutDaysToBuildHandler(
+        IConfigElementRepository configElementRepository,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ChannelWriter<IBackgroundServiceRequest> workerChannel)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
-
-        public UpdatePlayoutDaysToBuildHandler(
-            IConfigElementRepository configElementRepository,
-            IDbContextFactory<TvContext> dbContextFactory,
-            ChannelWriter<IBackgroundServiceRequest> workerChannel)
-        {
-            _configElementRepository = configElementRepository;
-            _dbContextFactory = dbContextFactory;
-            _workerChannel = workerChannel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            UpdatePlayoutDaysToBuild request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Unit> validation = await Validate(request);
-            return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(dbContext, request.DaysToBuild));
-        }
-
-        private async Task<Unit> ApplyUpdate(TvContext dbContext, int daysToBuild)
-        {
-            await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, daysToBuild);
-            
-            // build all playouts to proper number of days
-            List<Playout> playouts = await dbContext.Playouts
-                .Include(p => p.Channel)
-                .ToListAsync();
-            foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)).Map(p => p.Id))
-            {
-                await _workerChannel.WriteAsync(new BuildPlayout(playoutId));
-            }
-            
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, Unit>> Validate(UpdatePlayoutDaysToBuild request) =>
-            Optional(request.DaysToBuild)
-                .Where(days => days > 0)
-                .Map(_ => Unit.Default)
-                .ToValidation<BaseError>("Days to build must be greater than zero")
-                .AsTask();
+        _configElementRepository = configElementRepository;
+        _dbContextFactory = dbContextFactory;
+        _workerChannel = workerChannel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdatePlayoutDaysToBuild request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Unit> validation = await Validate(request);
+        return await validation.Apply<Unit, Unit>(_ => ApplyUpdate(dbContext, request.DaysToBuild));
+    }
+
+    private async Task<Unit> ApplyUpdate(TvContext dbContext, int daysToBuild)
+    {
+        await _configElementRepository.Upsert(ConfigElementKey.PlayoutDaysToBuild, daysToBuild);
+            
+        // build all playouts to proper number of days
+        List<Playout> playouts = await dbContext.Playouts
+            .Include(p => p.Channel)
+            .ToListAsync();
+        foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)).Map(p => p.Id))
+        {
+            await _workerChannel.WriteAsync(new BuildPlayout(playoutId));
+        }
+            
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, Unit>> Validate(UpdatePlayoutDaysToBuild request) =>
+        Optional(request.DaysToBuild)
+            .Where(days => days > 0)
+            .Map(_ => Unit.Default)
+            .ToValidation<BaseError>("Days to build must be greater than zero")
+            .AsTask();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/ConfigElementViewModel.cs b/ErsatzTV.Application/Configuration/ConfigElementViewModel.cs
index e50b44cdf..6cd251466 100644
--- a/ErsatzTV.Application/Configuration/ConfigElementViewModel.cs
+++ b/ErsatzTV.Application/Configuration/ConfigElementViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Configuration
-{
-    public record ConfigElementViewModel(string Key, string Value);
-}
+namespace ErsatzTV.Application.Configuration;
+
+public record ConfigElementViewModel(string Key, string Value);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Mapper.cs b/ErsatzTV.Application/Configuration/Mapper.cs
index bffed599d..9731588d8 100644
--- a/ErsatzTV.Application/Configuration/Mapper.cs
+++ b/ErsatzTV.Application/Configuration/Mapper.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Configuration
+namespace ErsatzTV.Application.Configuration;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static ConfigElementViewModel ProjectToViewModel(ConfigElement element) =>
-            new(element.Key, element.Value);
-    }
-}
+    internal static ConfigElementViewModel ProjectToViewModel(ConfigElement element) =>
+        new(element.Key, element.Value);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs b/ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs
index 96e6368c1..5f62f1922 100644
--- a/ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs
+++ b/ErsatzTV.Application/Configuration/Queries/GetConfigElementByKey.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Configuration.Queries
-{
-    public record GetConfigElementByKey(ConfigElementKey Key) : IRequest<Option<ConfigElementViewModel>>;
-}
+namespace ErsatzTV.Application.Configuration;
+
+public record GetConfigElementByKey(ConfigElementKey Key) : IRequest<Option<ConfigElementViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs b/ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs
index 76bac5641..c99996f96 100644
--- a/ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs
+++ b/ErsatzTV.Application/Configuration/Queries/GetConfigElementByKeyHandler.cs
@@ -1,22 +1,17 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Configuration.Mapper;
 
-namespace ErsatzTV.Application.Configuration.Queries
+namespace ErsatzTV.Application.Configuration;
+
+public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKey, Option<ConfigElementViewModel>>
 {
-    public class GetConfigElementByKeyHandler : IRequestHandler<GetConfigElementByKey, Option<ConfigElementViewModel>>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
+    private readonly IConfigElementRepository _configElementRepository;
 
-        public GetConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+    public GetConfigElementByKeyHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
 
-        public Task<Option<ConfigElementViewModel>> Handle(
-            GetConfigElementByKey request,
-            CancellationToken cancellationToken) =>
-            _configElementRepository.Get(request.Key).MapT(ProjectToViewModel);
-    }
-}
+    public Task<Option<ConfigElementViewModel>> Handle(
+        GetConfigElementByKey request,
+        CancellationToken cancellationToken) =>
+        _configElementRepository.Get(request.Key).MapT(ProjectToViewModel);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs b/ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs
index 5c36b1ae9..bf727dc55 100644
--- a/ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs
+++ b/ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshInterval.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.Configuration;
 
-namespace ErsatzTV.Application.Configuration.Queries
-{
-    public record GetLibraryRefreshInterval : IRequest<int>;
-}
+public record GetLibraryRefreshInterval : IRequest<int>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs b/ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs
index 1ccdd82e9..ad737c3fc 100644
--- a/ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs
+++ b/ErsatzTV.Application/Configuration/Queries/GetLibraryRefreshIntervalHandler.cs
@@ -1,21 +1,16 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Configuration.Queries
+namespace ErsatzTV.Application.Configuration;
+
+public class GetLibraryRefreshIntervalHandler : IRequestHandler<GetLibraryRefreshInterval, int>
 {
-    public class GetLibraryRefreshIntervalHandler : IRequestHandler<GetLibraryRefreshInterval, int>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
+    private readonly IConfigElementRepository _configElementRepository;
 
-        public GetLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+    public GetLibraryRefreshIntervalHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
 
-        public Task<int> Handle(GetLibraryRefreshInterval request, CancellationToken cancellationToken) =>
-            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
-                .Map(result => result.IfNone(6));
-    }
-}
+    public Task<int> Handle(GetLibraryRefreshInterval request, CancellationToken cancellationToken) =>
+        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+            .Map(result => result.IfNone(6));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs b/ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs
index b17e1609f..190bb5208 100644
--- a/ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs
+++ b/ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuild.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.Configuration;
 
-namespace ErsatzTV.Application.Configuration.Queries
-{
-    public record GetPlayoutDaysToBuild : IRequest<int>;
-}
+public record GetPlayoutDaysToBuild : IRequest<int>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.cs b/ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.cs
index a328abcf1..036f0ea0f 100644
--- a/ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.cs
+++ b/ErsatzTV.Application/Configuration/Queries/GetPlayoutDaysToBuildHandler.cs
@@ -1,21 +1,16 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Configuration.Queries
+namespace ErsatzTV.Application.Configuration;
+
+public class GetPlayoutDaysToBuildHandler : IRequestHandler<GetPlayoutDaysToBuild, int>
 {
-    public class GetPlayoutDaysToBuildHandler : IRequestHandler<GetPlayoutDaysToBuild, int>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
+    private readonly IConfigElementRepository _configElementRepository;
 
-        public GetPlayoutDaysToBuildHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+    public GetPlayoutDaysToBuildHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
 
-        public Task<int> Handle(GetPlayoutDaysToBuild request, CancellationToken cancellationToken) =>
-            _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild)
-                .Map(result => result.IfNone(2));
-    }
-}
+    public Task<int> Handle(GetPlayoutDaysToBuild request, CancellationToken cancellationToken) =>
+        _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild)
+            .Map(result => result.IfNone(2));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs b/ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs
index 29f6474fc..d6a530dac 100644
--- a/ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs
+++ b/ErsatzTV.Application/Emby/Commands/DisconnectEmby.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
-{
-    public record DisconnectEmby : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Emby;
+
+public record DisconnectEmby : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs b/ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs
index 0e950cd85..7d72ea1b6 100644
--- a/ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/DisconnectEmbyHandler.cs
@@ -1,46 +1,41 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class DisconnectEmbyHandler : MediatR.IRequestHandler<DisconnectEmby, Either<BaseError, Unit>>
 {
-    public class DisconnectEmbyHandler : MediatR.IRequestHandler<DisconnectEmby, Either<BaseError, Unit>>
+    private readonly IEmbySecretStore _embySecretStore;
+    private readonly IEntityLocker _entityLocker;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public DisconnectEmbyHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IEmbySecretStore embySecretStore,
+        IEntityLocker entityLocker,
+        ISearchIndex searchIndex)
     {
-        private readonly IEmbySecretStore _embySecretStore;
-        private readonly IEntityLocker _entityLocker;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public DisconnectEmbyHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IEmbySecretStore embySecretStore,
-            IEntityLocker entityLocker,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _embySecretStore = embySecretStore;
-            _entityLocker = entityLocker;
-            _searchIndex = searchIndex;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DisconnectEmby request,
-            CancellationToken cancellationToken)
-        {
-            List<int> ids = await _mediaSourceRepository.DeleteAllEmby();
-            await _searchIndex.RemoveItems(ids);
-            _searchIndex.Commit();
-            await _embySecretStore.DeleteAll();
-            _entityLocker.UnlockRemoteMediaSource<EmbyMediaSource>();
-
-            return Unit.Default;
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _embySecretStore = embySecretStore;
+        _entityLocker = entityLocker;
+        _searchIndex = searchIndex;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DisconnectEmby request,
+        CancellationToken cancellationToken)
+    {
+        List<int> ids = await _mediaSourceRepository.DeleteAllEmby();
+        await _searchIndex.RemoveItems(ids);
+        _searchIndex.Commit();
+        await _embySecretStore.DeleteAll();
+        _entityLocker.UnlockRemoteMediaSource<EmbyMediaSource>();
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/SaveEmbySecrets.cs b/ErsatzTV.Application/Emby/Commands/SaveEmbySecrets.cs
index 5657d165f..673556409 100644
--- a/ErsatzTV.Application/Emby/Commands/SaveEmbySecrets.cs
+++ b/ErsatzTV.Application/Emby/Commands/SaveEmbySecrets.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Emby;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
-{
-    public record SaveEmbySecrets(EmbySecrets Secrets) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Emby;
+
+public record SaveEmbySecrets(EmbySecrets Secrets) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs b/ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs
index 7fd4ecb06..87909125f 100644
--- a/ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/SaveEmbySecretsHandler.cs
@@ -1,60 +1,56 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class SaveEmbySecretsHandler : MediatR.IRequestHandler<SaveEmbySecrets, Either<BaseError, Unit>>
 {
-    public class SaveEmbySecretsHandler : MediatR.IRequestHandler<SaveEmbySecrets, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+    private readonly IEmbyApiClient _embyApiClient;
+    private readonly IEmbySecretStore _embySecretStore;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public SaveEmbySecretsHandler(
+        IEmbySecretStore embySecretStore,
+        IEmbyApiClient embyApiClient,
+        IMediaSourceRepository mediaSourceRepository,
+        ChannelWriter<IEmbyBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
-        private readonly IEmbyApiClient _embyApiClient;
-        private readonly IEmbySecretStore _embySecretStore;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-
-        public SaveEmbySecretsHandler(
-            IEmbySecretStore embySecretStore,
-            IEmbyApiClient embyApiClient,
-            IMediaSourceRepository mediaSourceRepository,
-            ChannelWriter<IEmbyBackgroundServiceRequest> channel)
-        {
-            _embySecretStore = embySecretStore;
-            _embyApiClient = embyApiClient;
-            _mediaSourceRepository = mediaSourceRepository;
-            _channel = channel;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(SaveEmbySecrets request, CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(PerformSave)
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<Validation<BaseError, Parameters>> Validate(SaveEmbySecrets request)
-        {
-            Either<BaseError, EmbyServerInformation> maybeServerInformation = await _embyApiClient
-                .GetServerInformation(request.Secrets.Address, request.Secrets.ApiKey);
-
-            return maybeServerInformation.Match(
-                info => Validation<BaseError, Parameters>.Success(new Parameters(request.Secrets, info)),
-                error => error);
-        }
-
-        private async Task<Unit> PerformSave(Parameters parameters)
-        {
-            await _embySecretStore.SaveSecrets(parameters.Secrets);
-            await _mediaSourceRepository.UpsertEmby(
-                parameters.Secrets.Address,
-                parameters.ServerInformation.ServerName,
-                parameters.ServerInformation.OperatingSystem);
-            await _channel.WriteAsync(new SynchronizeEmbyMediaSources());
-
-            return Unit.Default;
-        }
-
-        private record Parameters(EmbySecrets Secrets, EmbyServerInformation ServerInformation);
+        _embySecretStore = embySecretStore;
+        _embyApiClient = embyApiClient;
+        _mediaSourceRepository = mediaSourceRepository;
+        _channel = channel;
     }
-}
+
+    public Task<Either<BaseError, Unit>> Handle(SaveEmbySecrets request, CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(PerformSave)
+            .Bind(v => v.ToEitherAsync());
+
+    private async Task<Validation<BaseError, Parameters>> Validate(SaveEmbySecrets request)
+    {
+        Either<BaseError, EmbyServerInformation> maybeServerInformation = await _embyApiClient
+            .GetServerInformation(request.Secrets.Address, request.Secrets.ApiKey);
+
+        return maybeServerInformation.Match(
+            info => Validation<BaseError, Parameters>.Success(new Parameters(request.Secrets, info)),
+            error => error);
+    }
+
+    private async Task<Unit> PerformSave(Parameters parameters)
+    {
+        await _embySecretStore.SaveSecrets(parameters.Secrets);
+        await _mediaSourceRepository.UpsertEmby(
+            parameters.Secrets.Address,
+            parameters.ServerInformation.ServerName,
+            parameters.ServerInformation.OperatingSystem);
+        await _channel.WriteAsync(new SynchronizeEmbyMediaSources());
+
+        return Unit.Default;
+    }
+
+    private record Parameters(EmbySecrets Secrets, EmbyServerInformation ServerInformation);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs
index 1430d2420..f6eb659c4 100644
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraries.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
-{
-    public record SynchronizeEmbyLibraries(int EmbyMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
-        IEmbyBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Emby;
+
+public record SynchronizeEmbyLibraries(int EmbyMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+    IEmbyBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs
index f45065233..4ac5ca56a 100644
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs
@@ -1,118 +1,111 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class
+    SynchronizeEmbyLibrariesHandler : MediatR.IRequestHandler<SynchronizeEmbyLibraries, Either<BaseError, Unit>>
 {
-    public class
-        SynchronizeEmbyLibrariesHandler : MediatR.IRequestHandler<SynchronizeEmbyLibraries, Either<BaseError, Unit>>
+    private readonly IEmbyApiClient _embyApiClient;
+    private readonly IEmbySecretStore _embySecretStore;
+    private readonly ILogger<SynchronizeEmbyLibrariesHandler> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public SynchronizeEmbyLibrariesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IEmbySecretStore embySecretStore,
+        IEmbyApiClient embyApiClient,
+        ILogger<SynchronizeEmbyLibrariesHandler> logger,
+        ISearchIndex searchIndex)
     {
-        private readonly IEmbyApiClient _embyApiClient;
-        private readonly IEmbySecretStore _embySecretStore;
-        private readonly ILogger<SynchronizeEmbyLibrariesHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public SynchronizeEmbyLibrariesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IEmbySecretStore embySecretStore,
-            IEmbyApiClient embyApiClient,
-            ILogger<SynchronizeEmbyLibrariesHandler> logger,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _embySecretStore = embySecretStore;
-            _embyApiClient = embyApiClient;
-            _logger = logger;
-            _searchIndex = searchIndex;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(
-            SynchronizeEmbyLibraries request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(SynchronizeLibraries)
-                .Bind(v => v.ToEitherAsync());
-
-        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeEmbyLibraries request) =>
-            MediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveApiKey);
-
-        private Task<Validation<BaseError, EmbyMediaSource>> MediaSourceMustExist(
-            SynchronizeEmbyLibraries request) =>
-            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
-                .Map(o => o.ToValidation<BaseError>("Emby media source does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            EmbyMediaSource embyMediaSource)
-        {
-            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
-            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
-                .ToValidation<BaseError>("Emby media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
-            ConnectionParameters connectionParameters)
-        {
-            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
-            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Where(match => match)
-                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
-                .ToValidation<BaseError>("Emby media source requires an api key");
-        }
-
-        private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
-        {
-            Either<BaseError, List<EmbyLibrary>> maybeLibraries = await _embyApiClient.GetLibraries(
-                connectionParameters.ActiveConnection.Address,
-                connectionParameters.ApiKey);
-
-            await maybeLibraries.Match(
-                async libraries =>
-                {
-                    var existing = connectionParameters.EmbyMediaSource.Libraries.OfType<EmbyLibrary>()
-                        .ToList();
-                    var toAdd = libraries.Filter(library => existing.All(l => l.ItemId != library.ItemId)).ToList();
-                    var toRemove = existing.Filter(library => libraries.All(l => l.ItemId != library.ItemId)).ToList();
-                    List<int> ids = await _mediaSourceRepository.UpdateLibraries(
-                        connectionParameters.EmbyMediaSource.Id,
-                        toAdd,
-                        toRemove);
-                    if (ids.Any())
-                    {
-                        await _searchIndex.RemoveItems(ids);
-                        _searchIndex.Commit();
-                    }
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Unable to synchronize libraries from emby server {EmbyServer}: {Error}",
-                        connectionParameters.EmbyMediaSource.ServerName,
-                        error.Value);
-
-                    return Task.CompletedTask;
-                });
-
-            return Unit.Default;
-        }
-
-        private record ConnectionParameters(
-            EmbyMediaSource EmbyMediaSource,
-            EmbyConnection ActiveConnection)
-        {
-            public string ApiKey { get; set; }
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _embySecretStore = embySecretStore;
+        _embyApiClient = embyApiClient;
+        _logger = logger;
+        _searchIndex = searchIndex;
     }
-}
+
+    public Task<Either<BaseError, Unit>> Handle(
+        SynchronizeEmbyLibraries request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(SynchronizeLibraries)
+            .Bind(v => v.ToEitherAsync());
+
+    private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeEmbyLibraries request) =>
+        MediaSourceMustExist(request)
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveApiKey);
+
+    private Task<Validation<BaseError, EmbyMediaSource>> MediaSourceMustExist(
+        SynchronizeEmbyLibraries request) =>
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
+            .Map(o => o.ToValidation<BaseError>("Emby media source does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        EmbyMediaSource embyMediaSource)
+    {
+        Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
+        return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+            .ToValidation<BaseError>("Emby media source requires an active connection");
+    }
+
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+        ConnectionParameters connectionParameters)
+    {
+        EmbySecrets secrets = await _embySecretStore.ReadSecrets();
+        return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+            .Where(match => match)
+            .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+            .ToValidation<BaseError>("Emby media source requires an api key");
+    }
+
+    private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
+    {
+        Either<BaseError, List<EmbyLibrary>> maybeLibraries = await _embyApiClient.GetLibraries(
+            connectionParameters.ActiveConnection.Address,
+            connectionParameters.ApiKey);
+
+        await maybeLibraries.Match(
+            async libraries =>
+            {
+                var existing = connectionParameters.EmbyMediaSource.Libraries.OfType<EmbyLibrary>()
+                    .ToList();
+                var toAdd = libraries.Filter(library => existing.All(l => l.ItemId != library.ItemId)).ToList();
+                var toRemove = existing.Filter(library => libraries.All(l => l.ItemId != library.ItemId)).ToList();
+                List<int> ids = await _mediaSourceRepository.UpdateLibraries(
+                    connectionParameters.EmbyMediaSource.Id,
+                    toAdd,
+                    toRemove);
+                if (ids.Any())
+                {
+                    await _searchIndex.RemoveItems(ids);
+                    _searchIndex.Commit();
+                }
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Unable to synchronize libraries from emby server {EmbyServer}: {Error}",
+                    connectionParameters.EmbyMediaSource.ServerName,
+                    error.Value);
+
+                return Task.CompletedTask;
+            });
+
+        return Unit.Default;
+    }
+
+    private record ConnectionParameters(
+        EmbyMediaSource EmbyMediaSource,
+        EmbyConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs
index 7cadcc141..1901e0b45 100644
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryById.cs
@@ -1,23 +1,20 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>,
+    IEmbyBackgroundServiceRequest
 {
-    public interface ISynchronizeEmbyLibraryById : IRequest<Either<BaseError, string>>,
-        IEmbyBackgroundServiceRequest
-    {
-        int EmbyLibraryId { get; }
-        bool ForceScan { get; }
-    }
-
-    public record SynchronizeEmbyLibraryByIdIfNeeded(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
-    {
-        public bool ForceScan => false;
-    }
-
-    public record ForceSynchronizeEmbyLibraryById(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
-    {
-        public bool ForceScan => true;
-    }
+    int EmbyLibraryId { get; }
+    bool ForceScan { get; }
 }
+
+public record SynchronizeEmbyLibraryByIdIfNeeded(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+{
+    public bool ForceScan => false;
+}
+
+public record ForceSynchronizeEmbyLibraryById(int EmbyLibraryId) : ISynchronizeEmbyLibraryById
+{
+    public bool ForceScan => true;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs
index 36fd9cde7..76770d6a5 100644
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs
@@ -1,181 +1,172 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class SynchronizeEmbyLibraryByIdHandler :
+    IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
 {
-    public class SynchronizeEmbyLibraryByIdHandler :
-        IRequestHandler<ForceSynchronizeEmbyLibraryById, Either<BaseError, string>>,
-        IRequestHandler<SynchronizeEmbyLibraryByIdIfNeeded, Either<BaseError, string>>
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly IEmbyMovieLibraryScanner _embyMovieLibraryScanner;
+
+    private readonly IEmbySecretStore _embySecretStore;
+    private readonly IEmbyTelevisionLibraryScanner _embyTelevisionLibraryScanner;
+    private readonly IEntityLocker _entityLocker;
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILogger<SynchronizeEmbyLibraryByIdHandler> _logger;
+
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public SynchronizeEmbyLibraryByIdHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IEmbySecretStore embySecretStore,
+        IEmbyMovieLibraryScanner embyMovieLibraryScanner,
+        IEmbyTelevisionLibraryScanner embyTelevisionLibraryScanner,
+        ILibraryRepository libraryRepository,
+        IEntityLocker entityLocker,
+        IConfigElementRepository configElementRepository,
+        ILogger<SynchronizeEmbyLibraryByIdHandler> logger)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly IEmbyMovieLibraryScanner _embyMovieLibraryScanner;
-
-        private readonly IEmbySecretStore _embySecretStore;
-        private readonly IEmbyTelevisionLibraryScanner _embyTelevisionLibraryScanner;
-        private readonly IEntityLocker _entityLocker;
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILogger<SynchronizeEmbyLibraryByIdHandler> _logger;
-
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-
-        public SynchronizeEmbyLibraryByIdHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IEmbySecretStore embySecretStore,
-            IEmbyMovieLibraryScanner embyMovieLibraryScanner,
-            IEmbyTelevisionLibraryScanner embyTelevisionLibraryScanner,
-            ILibraryRepository libraryRepository,
-            IEntityLocker entityLocker,
-            IConfigElementRepository configElementRepository,
-            ILogger<SynchronizeEmbyLibraryByIdHandler> logger)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _embySecretStore = embySecretStore;
-            _embyMovieLibraryScanner = embyMovieLibraryScanner;
-            _embyTelevisionLibraryScanner = embyTelevisionLibraryScanner;
-            _libraryRepository = libraryRepository;
-            _entityLocker = entityLocker;
-            _configElementRepository = configElementRepository;
-            _logger = logger;
-        }
-
-        public Task<Either<BaseError, string>> Handle(
-            ForceSynchronizeEmbyLibraryById request,
-            CancellationToken cancellationToken) => Handle(request);
-
-        public Task<Either<BaseError, string>> Handle(
-            SynchronizeEmbyLibraryByIdIfNeeded request,
-            CancellationToken cancellationToken) => Handle(request);
-
-        private Task<Either<BaseError, string>>
-            Handle(ISynchronizeEmbyLibraryById request) =>
-            Validate(request)
-                .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<Unit> Synchronize(RequestParameters parameters)
-        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
-            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
-            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
-            {
-                switch (parameters.Library.MediaKind)
-                {
-                    case LibraryMediaKind.Movies:
-                        await _embyMovieLibraryScanner.ScanLibrary(
-                            parameters.ConnectionParameters.ActiveConnection.Address,
-                            parameters.ConnectionParameters.ApiKey,
-                            parameters.Library,
-                            parameters.FFprobePath);
-                        break;
-                    case LibraryMediaKind.Shows:
-                        await _embyTelevisionLibraryScanner.ScanLibrary(
-                            parameters.ConnectionParameters.ActiveConnection.Address,
-                            parameters.ConnectionParameters.ApiKey,
-                            parameters.Library,
-                            parameters.FFprobePath);
-                        break;
-                }
-
-                parameters.Library.LastScan = DateTime.UtcNow;
-                await _libraryRepository.UpdateLastScan(parameters.Library);
-            }
-            else
-            {
-                _logger.LogDebug(
-                    "Skipping unforced scan of emby media library {Name}",
-                    parameters.Library.Name);
-            }
-
-            _entityLocker.UnlockLibrary(parameters.Library.Id);
-            return Unit.Default;
-        }
-
-        private async Task<Validation<BaseError, RequestParameters>> Validate(
-            ISynchronizeEmbyLibraryById request) =>
-            (await ValidateConnection(request), await EmbyLibraryMustExist(request),
-                await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
-            .Apply(
-                (connectionParameters, embyLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
-                    connectionParameters,
-                    embyLibrary,
-                    request.ForceScan,
-                    libraryRefreshInterval,
-                    ffprobePath
-                ));
-
-        private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
-            ISynchronizeEmbyLibraryById request) =>
-            EmbyMediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveApiKey);
-
-        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
-            ISynchronizeEmbyLibraryById request) =>
-            _mediaSourceRepository.GetEmbyByLibraryId(request.EmbyLibraryId)
-                .Map(
-                    v => v.ToValidation<BaseError>(
-                        $"Emby media source for library {request.EmbyLibraryId} does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            EmbyMediaSource embyMediaSource)
-        {
-            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
-            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
-                .ToValidation<BaseError>("Emby media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
-            ConnectionParameters connectionParameters)
-        {
-            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
-            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Where(match => match)
-                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
-                .ToValidation<BaseError>("Emby media source requires an api key");
-        }
-
-        private Task<Validation<BaseError, EmbyLibrary>> EmbyLibraryMustExist(
-            ISynchronizeEmbyLibraryById request) =>
-            _mediaSourceRepository.GetEmbyLibrary(request.EmbyLibraryId)
-                .Map(v => v.ToValidation<BaseError>($"Emby library {request.EmbyLibraryId} does not exist."));
-
-        private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
-            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
-                .FilterT(lri => lri > 0)
-                .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
-
-        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
-            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
-                .FilterT(File.Exists)
-                .Map(
-                    ffprobePath =>
-                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
-
-        private record RequestParameters(
-            ConnectionParameters ConnectionParameters,
-            EmbyLibrary Library,
-            bool ForceScan,
-            int LibraryRefreshInterval,
-            string FFprobePath);
-
-        private record ConnectionParameters(
-            EmbyMediaSource EmbyMediaSource,
-            EmbyConnection ActiveConnection)
-        {
-            public string ApiKey { get; set; }
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _embySecretStore = embySecretStore;
+        _embyMovieLibraryScanner = embyMovieLibraryScanner;
+        _embyTelevisionLibraryScanner = embyTelevisionLibraryScanner;
+        _libraryRepository = libraryRepository;
+        _entityLocker = entityLocker;
+        _configElementRepository = configElementRepository;
+        _logger = logger;
     }
-}
+
+    public Task<Either<BaseError, string>> Handle(
+        ForceSynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken) => Handle(request);
+
+    public Task<Either<BaseError, string>> Handle(
+        SynchronizeEmbyLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request);
+
+    private Task<Either<BaseError, string>>
+        Handle(ISynchronizeEmbyLibraryById request) =>
+        Validate(request)
+            .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
+            .Bind(v => v.ToEitherAsync());
+
+    private async Task<Unit> Synchronize(RequestParameters parameters)
+    {
+        var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
+        if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
+        {
+            switch (parameters.Library.MediaKind)
+            {
+                case LibraryMediaKind.Movies:
+                    await _embyMovieLibraryScanner.ScanLibrary(
+                        parameters.ConnectionParameters.ActiveConnection.Address,
+                        parameters.ConnectionParameters.ApiKey,
+                        parameters.Library,
+                        parameters.FFprobePath);
+                    break;
+                case LibraryMediaKind.Shows:
+                    await _embyTelevisionLibraryScanner.ScanLibrary(
+                        parameters.ConnectionParameters.ActiveConnection.Address,
+                        parameters.ConnectionParameters.ApiKey,
+                        parameters.Library,
+                        parameters.FFprobePath);
+                    break;
+            }
+
+            parameters.Library.LastScan = DateTime.UtcNow;
+            await _libraryRepository.UpdateLastScan(parameters.Library);
+        }
+        else
+        {
+            _logger.LogDebug(
+                "Skipping unforced scan of emby media library {Name}",
+                parameters.Library.Name);
+        }
+
+        _entityLocker.UnlockLibrary(parameters.Library.Id);
+        return Unit.Default;
+    }
+
+    private async Task<Validation<BaseError, RequestParameters>> Validate(
+        ISynchronizeEmbyLibraryById request) =>
+        (await ValidateConnection(request), await EmbyLibraryMustExist(request),
+            await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
+        .Apply(
+            (connectionParameters, embyLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
+                connectionParameters,
+                embyLibrary,
+                request.ForceScan,
+                libraryRefreshInterval,
+                ffprobePath
+            ));
+
+    private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
+        ISynchronizeEmbyLibraryById request) =>
+        EmbyMediaSourceMustExist(request)
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveApiKey);
+
+    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
+        ISynchronizeEmbyLibraryById request) =>
+        _mediaSourceRepository.GetEmbyByLibraryId(request.EmbyLibraryId)
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    $"Emby media source for library {request.EmbyLibraryId} does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        EmbyMediaSource embyMediaSource)
+    {
+        Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.HeadOrNone();
+        return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+            .ToValidation<BaseError>("Emby media source requires an active connection");
+    }
+
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+        ConnectionParameters connectionParameters)
+    {
+        EmbySecrets secrets = await _embySecretStore.ReadSecrets();
+        return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+            .Where(match => match)
+            .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+            .ToValidation<BaseError>("Emby media source requires an api key");
+    }
+
+    private Task<Validation<BaseError, EmbyLibrary>> EmbyLibraryMustExist(
+        ISynchronizeEmbyLibraryById request) =>
+        _mediaSourceRepository.GetEmbyLibrary(request.EmbyLibraryId)
+            .Map(v => v.ToValidation<BaseError>($"Emby library {request.EmbyLibraryId} does not exist."));
+
+    private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
+        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+            .FilterT(lri => lri > 0)
+            .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
+
+    private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
+        _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
+            .FilterT(File.Exists)
+            .Map(
+                ffprobePath =>
+                    ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
+
+    private record RequestParameters(
+        ConnectionParameters ConnectionParameters,
+        EmbyLibrary Library,
+        bool ForceScan,
+        int LibraryRefreshInterval,
+        string FFprobePath);
+
+    private record ConnectionParameters(
+        EmbyMediaSource EmbyMediaSource,
+        EmbyConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs
index 2ab43890b..0f162f168 100644
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSources.cs
@@ -1,11 +1,7 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Commands
-{
-    public record SynchronizeEmbyMediaSources : IRequest<Either<BaseError, List<EmbyMediaSource>>>,
-        IEmbyBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Emby;
+
+public record SynchronizeEmbyMediaSources : IRequest<Either<BaseError, List<EmbyMediaSource>>>,
+    IEmbyBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs
index 8a0fc9cb9..7750c6e05 100644
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyMediaSourcesHandler.cs
@@ -1,41 +1,35 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmbyMediaSources,
+    Either<BaseError, List<EmbyMediaSource>>>
 {
-    public class SynchronizeEmbyMediaSourcesHandler : IRequestHandler<SynchronizeEmbyMediaSources,
-        Either<BaseError, List<EmbyMediaSource>>>
+    private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public SynchronizeEmbyMediaSourcesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        ChannelWriter<IEmbyBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IEmbyBackgroundServiceRequest> _channel;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-
-        public SynchronizeEmbyMediaSourcesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            ChannelWriter<IEmbyBackgroundServiceRequest> channel)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, List<EmbyMediaSource>>> Handle(
-            SynchronizeEmbyMediaSources request,
-            CancellationToken cancellationToken)
-        {
-            List<EmbyMediaSource> mediaSources = await _mediaSourceRepository.GetAllEmby();
-            foreach (EmbyMediaSource mediaSource in mediaSources)
-            {
-                // await _channel.WriteAsync(new SynchronizeEmbyAdminUserId(mediaSource.Id), cancellationToken);
-                await _channel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);
-            }
-
-            return mediaSources;
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, List<EmbyMediaSource>>> Handle(
+        SynchronizeEmbyMediaSources request,
+        CancellationToken cancellationToken)
+    {
+        List<EmbyMediaSource> mediaSources = await _mediaSourceRepository.GetAllEmby();
+        foreach (EmbyMediaSource mediaSource in mediaSources)
+        {
+            // await _channel.WriteAsync(new SynchronizeEmbyAdminUserId(mediaSource.Id), cancellationToken);
+            await _channel.WriteAsync(new SynchronizeEmbyLibraries(mediaSource.Id), cancellationToken);
+        }
+
+        return mediaSources;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs b/ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs
index 0ce00cad2..5b11533da 100644
--- a/ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs
+++ b/ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferences.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Emby.Commands
-{
-    public record UpdateEmbyLibraryPreferences
-        (List<EmbyLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+namespace ErsatzTV.Application.Emby;
 
-    public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);
-}
+public record UpdateEmbyLibraryPreferences
+    (List<EmbyLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+public record EmbyLibraryPreference(int Id, bool ShouldSyncItems);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs b/ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs
index 273f320b2..556f5d3c9 100644
--- a/ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/UpdateEmbyLibraryPreferencesHandler.cs
@@ -1,42 +1,36 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class
+    UpdateEmbyLibraryPreferencesHandler : MediatR.IRequestHandler<UpdateEmbyLibraryPreferences,
+        Either<BaseError, Unit>>
 {
-    public class
-        UpdateEmbyLibraryPreferencesHandler : MediatR.IRequestHandler<UpdateEmbyLibraryPreferences,
-            Either<BaseError, Unit>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public UpdateEmbyLibraryPreferencesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        ISearchIndex searchIndex)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public UpdateEmbyLibraryPreferencesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _searchIndex = searchIndex;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            UpdateEmbyLibraryPreferences request,
-            CancellationToken cancellationToken)
-        {
-            var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
-            List<int> ids = await _mediaSourceRepository.DisableEmbyLibrarySync(toDisable);
-            await _searchIndex.RemoveItems(ids);
-            _searchIndex.Commit();
-
-            IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
-            await _mediaSourceRepository.EnableEmbyLibrarySync(toEnable);
-
-            return Unit.Default;
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _searchIndex = searchIndex;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateEmbyLibraryPreferences request,
+        CancellationToken cancellationToken)
+    {
+        var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
+        List<int> ids = await _mediaSourceRepository.DisableEmbyLibrarySync(toDisable);
+        await _searchIndex.RemoveItems(ids);
+        _searchIndex.Commit();
+
+        IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
+        await _mediaSourceRepository.EnableEmbyLibrarySync(toEnable);
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs b/ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs
index 6626cc5e4..90bdf1ed4 100644
--- a/ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs
+++ b/ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacements.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Emby.Commands
-{
-    public record UpdateEmbyPathReplacements(
-        int EmbyMediaSourceId,
-        List<EmbyPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+namespace ErsatzTV.Application.Emby;
 
-    public record EmbyPathReplacementItem(int Id, string EmbyPath, string LocalPath);
-}
+public record UpdateEmbyPathReplacements(
+    int EmbyMediaSourceId,
+    List<EmbyPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+public record EmbyPathReplacementItem(int Id, string EmbyPath, string LocalPath);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs b/ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs
index fe0af60d4..212b2ae72 100644
--- a/ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/UpdateEmbyPathReplacementsHandler.cs
@@ -1,55 +1,49 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Emby.Commands
+namespace ErsatzTV.Application.Emby;
+
+public class UpdateEmbyPathReplacementsHandler : MediatR.IRequestHandler<UpdateEmbyPathReplacements,
+    Either<BaseError, Unit>>
 {
-    public class UpdateEmbyPathReplacementsHandler : MediatR.IRequestHandler<UpdateEmbyPathReplacements,
-        Either<BaseError, Unit>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public UpdateEmbyPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
+
+    public Task<Either<BaseError, Unit>> Handle(
+        UpdateEmbyPathReplacements request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(pms => MergePathReplacements(request, pms))
+            .Bind(v => v.ToEitherAsync());
+
+    private Task<Unit> MergePathReplacements(
+        UpdateEmbyPathReplacements request,
+        EmbyMediaSource embyMediaSource)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        embyMediaSource.PathReplacements ??= new List<EmbyPathReplacement>();
 
-        public UpdateEmbyPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+        var incoming = request.PathReplacements.Map(Project).ToList();
 
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdateEmbyPathReplacements request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(pms => MergePathReplacements(request, pms))
-                .Bind(v => v.ToEitherAsync());
+        var toAdd = incoming.Filter(r => r.Id < 1).ToList();
+        var toRemove = embyMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
+        var toUpdate = incoming.Except(toAdd).ToList();
 
-        private Task<Unit> MergePathReplacements(
-            UpdateEmbyPathReplacements request,
-            EmbyMediaSource embyMediaSource)
-        {
-            embyMediaSource.PathReplacements ??= new List<EmbyPathReplacement>();
-
-            var incoming = request.PathReplacements.Map(Project).ToList();
-
-            var toAdd = incoming.Filter(r => r.Id < 1).ToList();
-            var toRemove = embyMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
-            var toUpdate = incoming.Except(toAdd).ToList();
-
-            return _mediaSourceRepository.UpdatePathReplacements(embyMediaSource.Id, toAdd, toUpdate, toRemove);
-        }
-
-        private static EmbyPathReplacement Project(EmbyPathReplacementItem vm) =>
-            new() { Id = vm.Id, EmbyPath = vm.EmbyPath, LocalPath = vm.LocalPath };
-
-        private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request) =>
-            EmbyMediaSourceMustExist(request);
-
-        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
-            UpdateEmbyPathReplacements request) =>
-            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
-                .Map(
-                    v => v.ToValidation<BaseError>(
-                        $"Emby media source {request.EmbyMediaSourceId} does not exist."));
+        return _mediaSourceRepository.UpdatePathReplacements(embyMediaSource.Id, toAdd, toUpdate, toRemove);
     }
-}
+
+    private static EmbyPathReplacement Project(EmbyPathReplacementItem vm) =>
+        new() { Id = vm.Id, EmbyPath = vm.EmbyPath, LocalPath = vm.LocalPath };
+
+    private Task<Validation<BaseError, EmbyMediaSource>> Validate(UpdateEmbyPathReplacements request) =>
+        EmbyMediaSourceMustExist(request);
+
+    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist(
+        UpdateEmbyPathReplacements request) =>
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId)
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    $"Emby media source {request.EmbyMediaSourceId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs b/ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs
index 579662dfd..73649b6d8 100644
--- a/ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs
+++ b/ErsatzTV.Application/Emby/EmbyConnectionParametersViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Emby
-{
-    public record EmbyConnectionParametersViewModel(string Address);
-}
+namespace ErsatzTV.Application.Emby;
+
+public record EmbyConnectionParametersViewModel(string Address);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs b/ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs
index afde64b28..af6e703ed 100644
--- a/ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs
+++ b/ErsatzTV.Application/Emby/EmbyLibraryViewModel.cs
@@ -1,8 +1,7 @@
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Emby
-{
-    public record EmbyLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems)
-        : LibraryViewModel("Emby", Id, Name, MediaKind);
-}
+namespace ErsatzTV.Application.Emby;
+
+public record EmbyLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems)
+    : LibraryViewModel("Emby", Id, Name, MediaKind);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs b/ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs
index b78a10c42..434530b4d 100644
--- a/ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs
+++ b/ErsatzTV.Application/Emby/EmbyMediaSourceViewModel.cs
@@ -1,9 +1,8 @@
 using ErsatzTV.Application.MediaSources;
 
-namespace ErsatzTV.Application.Emby
-{
-    public record EmbyMediaSourceViewModel(int Id, string Name, string Address) : RemoteMediaSourceViewModel(
-        Id,
-        Name,
-        Address);
-}
+namespace ErsatzTV.Application.Emby;
+
+public record EmbyMediaSourceViewModel(int Id, string Name, string Address) : RemoteMediaSourceViewModel(
+    Id,
+    Name,
+    Address);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs b/ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs
index e6da43b0c..da490cb7a 100644
--- a/ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs
+++ b/ErsatzTV.Application/Emby/EmbyPathReplacementViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Emby
-{
-    public record EmbyPathReplacementViewModel(int Id, string EmbyPath, string LocalPath);
-}
+namespace ErsatzTV.Application.Emby;
+
+public record EmbyPathReplacementViewModel(int Id, string EmbyPath, string LocalPath);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Mapper.cs b/ErsatzTV.Application/Emby/Mapper.cs
index 512edbab4..528f7bbb4 100644
--- a/ErsatzTV.Application/Emby/Mapper.cs
+++ b/ErsatzTV.Application/Emby/Mapper.cs
@@ -1,19 +1,18 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Emby
+namespace ErsatzTV.Application.Emby;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static EmbyMediaSourceViewModel ProjectToViewModel(EmbyMediaSource embyMediaSource) =>
-            new(
-                embyMediaSource.Id,
-                embyMediaSource.ServerName,
-                embyMediaSource.Connections.HeadOrNone().Match(c => c.Address, string.Empty));
+    internal static EmbyMediaSourceViewModel ProjectToViewModel(EmbyMediaSource embyMediaSource) =>
+        new(
+            embyMediaSource.Id,
+            embyMediaSource.ServerName,
+            embyMediaSource.Connections.HeadOrNone().Match(c => c.Address, string.Empty));
 
-        internal static EmbyLibraryViewModel ProjectToViewModel(EmbyLibrary library) =>
-            new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
+    internal static EmbyLibraryViewModel ProjectToViewModel(EmbyLibrary library) =>
+        new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
 
-        internal static EmbyPathReplacementViewModel ProjectToViewModel(EmbyPathReplacement pathReplacement) =>
-            new(pathReplacement.Id, pathReplacement.EmbyPath, pathReplacement.LocalPath);
-    }
-}
+    internal static EmbyPathReplacementViewModel ProjectToViewModel(EmbyPathReplacement pathReplacement) =>
+        new(pathReplacement.Id, pathReplacement.EmbyPath, pathReplacement.LocalPath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs b/ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs
index 9f0e6fc14..1334ac37f 100644
--- a/ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSources.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Emby;
 
-namespace ErsatzTV.Application.Emby.Queries
-{
-    public record GetAllEmbyMediaSources : IRequest<List<EmbyMediaSourceViewModel>>;
-}
+public record GetAllEmbyMediaSources : IRequest<List<EmbyMediaSourceViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs b/ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs
index d7615d6e2..d735fff24 100644
--- a/ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetAllEmbyMediaSourcesHandler.cs
@@ -1,24 +1,17 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Emby.Mapper;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class GetAllEmbyMediaSourcesHandler : IRequestHandler<GetAllEmbyMediaSources, List<EmbyMediaSourceViewModel>>
 {
-    public class GetAllEmbyMediaSourcesHandler : IRequestHandler<GetAllEmbyMediaSources, List<EmbyMediaSourceViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetAllEmbyMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetAllEmbyMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<EmbyMediaSourceViewModel>> Handle(
-            GetAllEmbyMediaSources request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetAllEmby().Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<EmbyMediaSourceViewModel>> Handle(
+        GetAllEmbyMediaSources request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetAllEmby().Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParameters.cs b/ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParameters.cs
index 6cc1f22fa..653d9cacc 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParameters.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParameters.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Queries
-{
-    public record GetEmbyConnectionParameters : IRequest<Either<BaseError, EmbyConnectionParametersViewModel>>;
-}
+namespace ErsatzTV.Application.Emby;
+
+public record GetEmbyConnectionParameters : IRequest<Either<BaseError, EmbyConnectionParametersViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs b/ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs
index c67315287..c85eca763 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbyConnectionParametersHandler.cs
@@ -1,73 +1,66 @@
-using System;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.Caching.Memory;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
+    Either<BaseError, EmbyConnectionParametersViewModel>>
 {
-    public class GetEmbyConnectionParametersHandler : IRequestHandler<GetEmbyConnectionParameters,
-        Either<BaseError, EmbyConnectionParametersViewModel>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMemoryCache _memoryCache;
+
+    public GetEmbyConnectionParametersHandler(
+        IMemoryCache memoryCache,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMemoryCache _memoryCache;
-
-        public GetEmbyConnectionParametersHandler(
-            IMemoryCache memoryCache,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _memoryCache = memoryCache;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
-            GetEmbyConnectionParameters request,
-            CancellationToken cancellationToken)
-        {
-            if (_memoryCache.TryGetValue(request, out EmbyConnectionParametersViewModel parameters))
-            {
-                return parameters;
-            }
-
-            Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
-                await Validate()
-                    .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address))
-                    .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
-
-            return maybeParameters.Match(
-                p =>
-                {
-                    _memoryCache.Set(request, p, TimeSpan.FromHours(1));
-                    return maybeParameters;
-                },
-                error => error);
-        }
-
-        private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
-            EmbyMediaSourceMustExist()
-                .BindT(MediaSourceMustHaveActiveConnection);
-
-        private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
-            _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
-                .Map(
-                    v => v.ToValidation<BaseError>(
-                        "Emby media source does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            EmbyMediaSource embyMediaSource)
-        {
-            Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.FirstOrDefault();
-            return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
-                .ToValidation<BaseError>("Emby media source requires an active connection");
-        }
-
-        private record ConnectionParameters(
-            EmbyMediaSource EmbyMediaSource,
-            EmbyConnection ActiveConnection);
+        _memoryCache = memoryCache;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<Either<BaseError, EmbyConnectionParametersViewModel>> Handle(
+        GetEmbyConnectionParameters request,
+        CancellationToken cancellationToken)
+    {
+        if (_memoryCache.TryGetValue(request, out EmbyConnectionParametersViewModel parameters))
+        {
+            return parameters;
+        }
+
+        Either<BaseError, EmbyConnectionParametersViewModel> maybeParameters =
+            await Validate()
+                .MapT(cp => new EmbyConnectionParametersViewModel(cp.ActiveConnection.Address))
+                .Map(v => v.ToEither<EmbyConnectionParametersViewModel>());
+
+        return maybeParameters.Match(
+            p =>
+            {
+                _memoryCache.Set(request, p, TimeSpan.FromHours(1));
+                return maybeParameters;
+            },
+            error => error);
+    }
+
+    private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+        EmbyMediaSourceMustExist()
+            .BindT(MediaSourceMustHaveActiveConnection);
+
+    private Task<Validation<BaseError, EmbyMediaSource>> EmbyMediaSourceMustExist() =>
+        _mediaSourceRepository.GetAllEmby().Map(list => list.HeadOrNone())
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    "Emby media source does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        EmbyMediaSource embyMediaSource)
+    {
+        Option<EmbyConnection> maybeConnection = embyMediaSource.Connections.FirstOrDefault();
+        return maybeConnection.Map(connection => new ConnectionParameters(embyMediaSource, connection))
+            .ToValidation<BaseError>("Emby media source requires an active connection");
+    }
+
+    private record ConnectionParameters(
+        EmbyMediaSource EmbyMediaSource,
+        EmbyConnection ActiveConnection);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceId.cs b/ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceId.cs
index 3bfad5589..5ac0f4afb 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceId.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceId.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Emby;
 
-namespace ErsatzTV.Application.Emby.Queries
-{
-    public record GetEmbyLibrariesBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyLibraryViewModel>>;
-}
+public record GetEmbyLibrariesBySourceId(int EmbyMediaSourceId) : IRequest<List<EmbyLibraryViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceIdHandler.cs b/ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceIdHandler.cs
index 758d5de64..dda6a3896 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceIdHandler.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbyLibrariesBySourceIdHandler.cs
@@ -1,26 +1,19 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Emby.Mapper;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class
+    GetEmbyLibrariesBySourceIdHandler : IRequestHandler<GetEmbyLibrariesBySourceId, List<EmbyLibraryViewModel>>
 {
-    public class
-        GetEmbyLibrariesBySourceIdHandler : IRequestHandler<GetEmbyLibrariesBySourceId, List<EmbyLibraryViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetEmbyLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetEmbyLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<EmbyLibraryViewModel>> Handle(
-            GetEmbyLibrariesBySourceId request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetEmbyLibraries(request.EmbyMediaSourceId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<EmbyLibraryViewModel>> Handle(
+        GetEmbyLibrariesBySourceId request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetEmbyLibraries(request.EmbyMediaSourceId)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceById.cs b/ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceById.cs
index f79a79935..3410201bc 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceById.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Emby;
 
-namespace ErsatzTV.Application.Emby.Queries
-{
-    public record GetEmbyMediaSourceById(int EmbyMediaSourceId) : IRequest<Option<EmbyMediaSourceViewModel>>;
-}
+public record GetEmbyMediaSourceById(int EmbyMediaSourceId) : IRequest<Option<EmbyMediaSourceViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs b/ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs
index b5e759646..24e8da6ec 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbyMediaSourceByIdHandler.cs
@@ -1,23 +1,18 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Emby.Mapper;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class
+    GetEmbyMediaSourceByIdHandler : IRequestHandler<GetEmbyMediaSourceById, Option<EmbyMediaSourceViewModel>>
 {
-    public class
-        GetEmbyMediaSourceByIdHandler : IRequestHandler<GetEmbyMediaSourceById, Option<EmbyMediaSourceViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetEmbyMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetEmbyMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<Option<EmbyMediaSourceViewModel>> Handle(
-            GetEmbyMediaSourceById request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
-    }
-}
+    public Task<Option<EmbyMediaSourceViewModel>> Handle(
+        GetEmbyMediaSourceById request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetEmby(request.EmbyMediaSourceId).MapT(ProjectToViewModel);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs b/ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs
index c26f3d585..678d31e91 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceId.cs
@@ -1,8 +1,4 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Emby;
 
-namespace ErsatzTV.Application.Emby.Queries
-{
-    public record GetEmbyPathReplacementsBySourceId
-        (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
-}
+public record GetEmbyPathReplacementsBySourceId
+    (int EmbyMediaSourceId) : IRequest<List<EmbyPathReplacementViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceIdHandler.cs b/ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceIdHandler.cs
index e5cab338f..db1dcbf96 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceIdHandler.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbyPathReplacementsBySourceIdHandler.cs
@@ -1,26 +1,19 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Emby.Mapper;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class GetEmbyPathReplacementsBySourceIdHandler : IRequestHandler<GetEmbyPathReplacementsBySourceId,
+    List<EmbyPathReplacementViewModel>>
 {
-    public class GetEmbyPathReplacementsBySourceIdHandler : IRequestHandler<GetEmbyPathReplacementsBySourceId,
-        List<EmbyPathReplacementViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetEmbyPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetEmbyPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<EmbyPathReplacementViewModel>> Handle(
-            GetEmbyPathReplacementsBySourceId request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetEmbyPathReplacements(request.EmbyMediaSourceId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<EmbyPathReplacementViewModel>> Handle(
+        GetEmbyPathReplacementsBySourceId request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetEmbyPathReplacements(request.EmbyMediaSourceId)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbySecrets.cs b/ErsatzTV.Application/Emby/Queries/GetEmbySecrets.cs
index 6123398cc..c15302ea7 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbySecrets.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbySecrets.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core.Emby;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Queries
-{
-    public record GetEmbySecrets : IRequest<EmbySecrets>;
-}
+namespace ErsatzTV.Application.Emby;
+
+public record GetEmbySecrets : IRequest<EmbySecrets>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Emby/Queries/GetEmbySecretsHandler.cs b/ErsatzTV.Application/Emby/Queries/GetEmbySecretsHandler.cs
index 1f075353d..9de15a250 100644
--- a/ErsatzTV.Application/Emby/Queries/GetEmbySecretsHandler.cs
+++ b/ErsatzTV.Application/Emby/Queries/GetEmbySecretsHandler.cs
@@ -1,19 +1,15 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Emby;
+using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
-using MediatR;
 
-namespace ErsatzTV.Application.Emby.Queries
+namespace ErsatzTV.Application.Emby;
+
+public class GetEmbySecretsHandler : IRequestHandler<GetEmbySecrets, EmbySecrets>
 {
-    public class GetEmbySecretsHandler : IRequestHandler<GetEmbySecrets, EmbySecrets>
-    {
-        private readonly IEmbySecretStore _embySecretStore;
+    private readonly IEmbySecretStore _embySecretStore;
 
-        public GetEmbySecretsHandler(IEmbySecretStore embySecretStore) =>
-            _embySecretStore = embySecretStore;
+    public GetEmbySecretsHandler(IEmbySecretStore embySecretStore) =>
+        _embySecretStore = embySecretStore;
 
-        public Task<EmbySecrets> Handle(GetEmbySecrets request, CancellationToken cancellationToken) =>
-            _embySecretStore.ReadSecrets();
-    }
-}
+    public Task<EmbySecrets> Handle(GetEmbySecrets request, CancellationToken cancellationToken) =>
+        _embySecretStore.ReadSecrets();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/EntityIdResult.cs b/ErsatzTV.Application/EntityIdResult.cs
index a39fdc7e3..feb3d4fb9 100644
--- a/ErsatzTV.Application/EntityIdResult.cs
+++ b/ErsatzTV.Application/EntityIdResult.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application
-{
-    public record EntityIdResult(int Id);
-}
+namespace ErsatzTV.Application;
+
+public record EntityIdResult(int Id);
\ No newline at end of file
diff --git a/ErsatzTV.Application/ErsatzTV.Application.csproj b/ErsatzTV.Application/ErsatzTV.Application.csproj
index a13ada020..ff363d636 100644
--- a/ErsatzTV.Application/ErsatzTV.Application.csproj
+++ b/ErsatzTV.Application/ErsatzTV.Application.csproj
@@ -3,6 +3,7 @@
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
+        <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings b/ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings
new file mode 100644
index 000000000..ab5fb558b
--- /dev/null
+++ b/ErsatzTV.Application/ErsatzTV.Application.csproj.DotSettings
@@ -0,0 +1,43 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=artists_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=channels_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=channels_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=configuration_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=configuration_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=emby_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=emby_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=ffmpegprofiles_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=filler_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=filler_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=hdhr_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=hdhr_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=health_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=images_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=images_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=jellyfin_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=jellyfin_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=libraries_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=libraries_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=logs_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=maintenance_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediacards_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediacollections_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediacollections_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediaitems_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediasources_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=movies_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=playouts_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=playouts_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=plex_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=plex_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=programschedules_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=programschedules_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=resolutions_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=search_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=search_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=streaming_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=streaming_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=television_005Cqueries/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Ccommands/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=watermarks_005Cqueries/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs
index c22736727..539d9b1b5 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfile.cs
@@ -1,9 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
-{
-    public record CopyFFmpegProfile
-        (int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
-}
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record CopyFFmpegProfile
+    (int FFmpegProfileId, string Name) : IRequest<Either<BaseError, FFmpegProfileViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs
index 9f702d652..1a4a4830e 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CopyFFmpegProfileHandler.cs
@@ -1,37 +1,32 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class
+    CopyFFmpegProfileHandler : IRequestHandler<CopyFFmpegProfile, Either<BaseError, FFmpegProfileViewModel>>
 {
-    public class
-        CopyFFmpegProfileHandler : IRequestHandler<CopyFFmpegProfile, Either<BaseError, FFmpegProfileViewModel>>
-    {
-        private readonly IFFmpegProfileRepository _ffmpegProfileRepository;
+    private readonly IFFmpegProfileRepository _ffmpegProfileRepository;
 
-        public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository) =>
-            _ffmpegProfileRepository = ffmpegProfileRepository;
+    public CopyFFmpegProfileHandler(IFFmpegProfileRepository ffmpegProfileRepository) =>
+        _ffmpegProfileRepository = ffmpegProfileRepository;
 
-        public Task<Either<BaseError, FFmpegProfileViewModel>> Handle(
-            CopyFFmpegProfile request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(PerformCopy)
-                .Bind(v => v.ToEitherAsync());
+    public Task<Either<BaseError, FFmpegProfileViewModel>> Handle(
+        CopyFFmpegProfile request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(PerformCopy)
+            .Bind(v => v.ToEitherAsync());
 
-        private Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request) =>
-            _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name)
-                .Map(ProjectToViewModel);
+    private Task<FFmpegProfileViewModel> PerformCopy(CopyFFmpegProfile request) =>
+        _ffmpegProfileRepository.Copy(request.FFmpegProfileId, request.Name)
+            .Map(ProjectToViewModel);
 
-        private Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
-            ValidateName(request).AsTask().MapT(_ => request);
+    private Task<Validation<BaseError, CopyFFmpegProfile>> Validate(CopyFFmpegProfile request) =>
+        ValidateName(request).AsTask().MapT(_ => request);
 
-        private Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
-            request.NotEmpty(x => x.Name)
-                .Bind(_ => request.NotLongerThan(50)(x => x.Name));
-    }
-}
+    private Validation<BaseError, string> ValidateName(CopyFFmpegProfile request) =>
+        request.NotEmpty(x => x.Name)
+            .Bind(_ => request.NotLongerThan(50)(x => x.Name));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs
index 4abfc0171..6f2c61427 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs
@@ -1,29 +1,26 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
-{
-    public record CreateFFmpegProfile(
-        string Name,
-        int ThreadCount,
-        bool Transcode,
-        HardwareAccelerationKind HardwareAcceleration,
-        VaapiDriver VaapiDriver,
-        string VaapiDevice,
-        int ResolutionId,
-        bool NormalizeVideo,
-        string VideoCodec,
-        int VideoBitrate,
-        int VideoBufferSize,
-        string AudioCodec,
-        int AudioBitrate,
-        int AudioBufferSize,
-        bool NormalizeLoudness,
-        int AudioChannels,
-        int AudioSampleRate,
-        bool NormalizeAudio,
-        bool NormalizeFramerate) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;
-}
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record CreateFFmpegProfile(
+    string Name,
+    int ThreadCount,
+    bool Transcode,
+    HardwareAccelerationKind HardwareAcceleration,
+    VaapiDriver VaapiDriver,
+    string VaapiDevice,
+    int ResolutionId,
+    bool NormalizeVideo,
+    string VideoCodec,
+    int VideoBitrate,
+    int VideoBufferSize,
+    string AudioCodec,
+    int AudioBitrate,
+    int AudioBufferSize,
+    bool NormalizeLoudness,
+    int AudioChannels,
+    int AudioSampleRate,
+    bool NormalizeAudio,
+    bool NormalizeFramerate) : IRequest<Either<BaseError, CreateFFmpegProfileResult>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs
index 173fe9181..673be2742 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs
@@ -1,80 +1,75 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class CreateFFmpegProfileHandler :
+    IRequestHandler<CreateFFmpegProfile, Either<BaseError, CreateFFmpegProfileResult>>
 {
-    public class CreateFFmpegProfileHandler :
-        IRequestHandler<CreateFFmpegProfile, Either<BaseError, CreateFFmpegProfileResult>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, CreateFFmpegProfileResult>> Handle(
+        CreateFFmpegProfile request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, CreateFFmpegProfileResult>> Handle(
-            CreateFFmpegProfile request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
-            return await validation.Apply(profile => PersistFFmpegProfile(dbContext, profile));
-        }
-
-        private static async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
-            TvContext dbContext,
-            FFmpegProfile ffmpegProfile)
-        {
-            await dbContext.FFmpegProfiles.AddAsync(ffmpegProfile);
-            await dbContext.SaveChangesAsync();
-            return new CreateFFmpegProfileResult(ffmpegProfile.Id);
-        }
-
-        private async Task<Validation<BaseError, FFmpegProfile>> Validate(TvContext dbContext, CreateFFmpegProfile request) =>
-            (ValidateName(request), ValidateThreadCount(request), await ResolutionMustExist(dbContext, request))
-            .Apply(
-                (name, threadCount, resolutionId) => new FFmpegProfile
-                {
-                    Name = name,
-                    ThreadCount = threadCount,
-                    Transcode = request.Transcode,
-                    HardwareAcceleration = request.HardwareAcceleration,
-                    VaapiDriver = request.VaapiDriver,
-                    VaapiDevice = request.VaapiDevice,
-                    ResolutionId = resolutionId,
-                    NormalizeVideo = request.NormalizeVideo,
-                    VideoCodec = request.VideoCodec,
-                    VideoBitrate = request.VideoBitrate,
-                    VideoBufferSize = request.VideoBufferSize,
-                    AudioCodec = request.AudioCodec,
-                    AudioBitrate = request.AudioBitrate,
-                    AudioBufferSize = request.AudioBufferSize,
-                    NormalizeLoudness = request.NormalizeLoudness,
-                    AudioChannels = request.AudioChannels,
-                    AudioSampleRate = request.AudioSampleRate,
-                    NormalizeAudio = request.NormalizeAudio,
-                    NormalizeFramerate = request.NormalizeFramerate
-                });
-
-        private static Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>
-            createFFmpegProfile.NotEmpty(x => x.Name)
-                .Bind(_ => createFFmpegProfile.NotLongerThan(50)(x => x.Name));
-
-        private static Validation<BaseError, int> ValidateThreadCount(CreateFFmpegProfile createFFmpegProfile) =>
-            createFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
-
-        private static Task<Validation<BaseError, int>> ResolutionMustExist(
-            TvContext dbContext,
-            CreateFFmpegProfile createFFmpegProfile) =>
-            dbContext.Resolutions
-                .SelectOneAsync(r => r.Id, r => r.Id == createFFmpegProfile.ResolutionId)
-                .MapT(r => r.Id)
-                .Map(o => o.ToValidation<BaseError>($"[Resolution] {createFFmpegProfile.ResolutionId} does not exist"));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, profile => PersistFFmpegProfile(dbContext, profile));
     }
-}
+
+    private static async Task<CreateFFmpegProfileResult> PersistFFmpegProfile(
+        TvContext dbContext,
+        FFmpegProfile ffmpegProfile)
+    {
+        await dbContext.FFmpegProfiles.AddAsync(ffmpegProfile);
+        await dbContext.SaveChangesAsync();
+        return new CreateFFmpegProfileResult(ffmpegProfile.Id);
+    }
+
+    private async Task<Validation<BaseError, FFmpegProfile>> Validate(TvContext dbContext, CreateFFmpegProfile request) =>
+        (ValidateName(request), ValidateThreadCount(request), await ResolutionMustExist(dbContext, request))
+        .Apply(
+            (name, threadCount, resolutionId) => new FFmpegProfile
+            {
+                Name = name,
+                ThreadCount = threadCount,
+                Transcode = request.Transcode,
+                HardwareAcceleration = request.HardwareAcceleration,
+                VaapiDriver = request.VaapiDriver,
+                VaapiDevice = request.VaapiDevice,
+                ResolutionId = resolutionId,
+                NormalizeVideo = request.NormalizeVideo,
+                VideoCodec = request.VideoCodec,
+                VideoBitrate = request.VideoBitrate,
+                VideoBufferSize = request.VideoBufferSize,
+                AudioCodec = request.AudioCodec,
+                AudioBitrate = request.AudioBitrate,
+                AudioBufferSize = request.AudioBufferSize,
+                NormalizeLoudness = request.NormalizeLoudness,
+                AudioChannels = request.AudioChannels,
+                AudioSampleRate = request.AudioSampleRate,
+                NormalizeAudio = request.NormalizeAudio,
+                NormalizeFramerate = request.NormalizeFramerate
+            });
+
+    private static Validation<BaseError, string> ValidateName(CreateFFmpegProfile createFFmpegProfile) =>
+        createFFmpegProfile.NotEmpty(x => x.Name)
+            .Bind(_ => createFFmpegProfile.NotLongerThan(50)(x => x.Name));
+
+    private static Validation<BaseError, int> ValidateThreadCount(CreateFFmpegProfile createFFmpegProfile) =>
+        createFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
+
+    private static Task<Validation<BaseError, int>> ResolutionMustExist(
+        TvContext dbContext,
+        CreateFFmpegProfile createFFmpegProfile) =>
+        dbContext.Resolutions
+            .SelectOneAsync(r => r.Id, r => r.Id == createFFmpegProfile.ResolutionId)
+            .MapT(r => r.Id)
+            .Map(o => o.ToValidation<BaseError>($"[Resolution] {createFFmpegProfile.ResolutionId} does not exist"));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileResult.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileResult.cs
index 25c68e0a3..f2a29e103 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileResult.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileResult.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
-{
-    public record CreateFFmpegProfileResult(int FFmpegProfileId) : EntityIdResult(FFmpegProfileId);
-}
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record CreateFFmpegProfileResult(int FFmpegProfileId) : EntityIdResult(FFmpegProfileId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfile.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfile.cs
index fc4c52448..6f630f9c6 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfile.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
-{
-    public record DeleteFFmpegProfile(int FFmpegProfileId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record DeleteFFmpegProfile(int FFmpegProfileId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs
index ae01345d0..b8041e3c6 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/DeleteFFmpegProfileHandler.cs
@@ -1,43 +1,38 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, Either<BaseError, LanguageExt.Unit>>
 {
-    public class DeleteFFmpegProfileHandler : IRequestHandler<DeleteFFmpegProfile, Either<BaseError, LanguageExt.Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeleteFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, LanguageExt.Unit>> Handle(
+        DeleteFFmpegProfile request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public DeleteFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, LanguageExt.Unit>> Handle(
-            DeleteFFmpegProfile request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, FFmpegProfile> validation = await FFmpegProfileMustExist(dbContext, request);
-            return await validation.Apply(p => DoDeletion(dbContext, p));
-        }
-
-        private static async Task<LanguageExt.Unit> DoDeletion(TvContext dbContext, FFmpegProfile ffmpegProfile)
-        {
-            dbContext.FFmpegProfiles.Remove(ffmpegProfile);
-            await dbContext.SaveChangesAsync();
-            return LanguageExt.Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
-            TvContext dbContext,
-            DeleteFFmpegProfile request) =>
-            dbContext.FFmpegProfiles
-                .SelectOneAsync(p => p.Id, p => p.Id == request.FFmpegProfileId)
-                .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {request.FFmpegProfileId} does not exist"));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, FFmpegProfile> validation = await FFmpegProfileMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, p => DoDeletion(dbContext, p));
     }
-}
+
+    private static async Task<LanguageExt.Unit> DoDeletion(TvContext dbContext, FFmpegProfile ffmpegProfile)
+    {
+        dbContext.FFmpegProfiles.Remove(ffmpegProfile);
+        await dbContext.SaveChangesAsync();
+        return LanguageExt.Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
+        TvContext dbContext,
+        DeleteFFmpegProfile request) =>
+        dbContext.FFmpegProfiles
+            .SelectOneAsync(p => p.Id, p => p.Id == request.FFmpegProfileId)
+            .Map(o => o.ToValidation<BaseError>($"FFmpegProfile {request.FFmpegProfileId} does not exist"));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfile.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfile.cs
index 1bcd94bee..f14242fdb 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfile.cs
@@ -1,10 +1,7 @@
-using MediatR;
+namespace ErsatzTV.Application.FFmpegProfiles;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
-{
-    /// <summary>
-    ///     Requests a new ffmpeg profile (view model) that contains
-    ///     appropriate default values.
-    /// </summary>
-    public record NewFFmpegProfile : IRequest<FFmpegProfileViewModel>;
-}
+/// <summary>
+///     Requests a new ffmpeg profile (view model) that contains
+///     appropriate default values.
+/// </summary>
+public record NewFFmpegProfile : IRequest<FFmpegProfileViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfileHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfileHandler.cs
index 1150feb29..77fbe4fa4 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/NewFFmpegProfileHandler.cs
@@ -1,39 +1,32 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class NewFFmpegProfileHandler : IRequestHandler<NewFFmpegProfile, FFmpegProfileViewModel>
 {
-    public class NewFFmpegProfileHandler : IRequestHandler<NewFFmpegProfile, FFmpegProfileViewModel>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public NewFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<FFmpegProfileViewModel> Handle(NewFFmpegProfile request, CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-        public NewFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        int defaultResolutionId = await dbContext.ConfigElements
+            .GetValue<int>(ConfigElementKey.FFmpegDefaultResolutionId)
+            .IfNoneAsync(0);
 
-        public async Task<FFmpegProfileViewModel> Handle(NewFFmpegProfile request, CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<Resolution> allResolutions = await dbContext.Resolutions
+            .ToListAsync(cancellationToken);
 
-            int defaultResolutionId = await dbContext.ConfigElements
-                .GetValue<int>(ConfigElementKey.FFmpegDefaultResolutionId)
-                .IfNoneAsync(0);
+        Option<Resolution> maybeDefaultResolution = allResolutions.Find(r => r.Id == defaultResolutionId);
+        Resolution defaultResolution = maybeDefaultResolution.Match(identity, () => allResolutions.Head());
 
-            List<Resolution> allResolutions = await dbContext.Resolutions
-                .ToListAsync(cancellationToken);
-
-            Option<Resolution> maybeDefaultResolution = allResolutions.Find(r => r.Id == defaultResolutionId);
-            Resolution defaultResolution = maybeDefaultResolution.Match(identity, () => allResolutions.Head());
-
-            return ProjectToViewModel(FFmpegProfile.New("New Profile", defaultResolution));
-        }
+        return ProjectToViewModel(FFmpegProfile.New("New Profile", defaultResolution));
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs
index 3c7d57ac3..7eded6ee0 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs
@@ -1,30 +1,27 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
-{
-    public record UpdateFFmpegProfile(
-        int FFmpegProfileId,
-        string Name,
-        int ThreadCount,
-        bool Transcode,
-        HardwareAccelerationKind HardwareAcceleration,
-        VaapiDriver VaapiDriver,
-        string VaapiDevice,
-        int ResolutionId,
-        bool NormalizeVideo,
-        string VideoCodec,
-        int VideoBitrate,
-        int VideoBufferSize,
-        string AudioCodec,
-        int AudioBitrate,
-        int AudioBufferSize,
-        bool NormalizeLoudness,
-        int AudioChannels,
-        int AudioSampleRate,
-        bool NormalizeAudio,
-        bool NormalizeFramerate) : IRequest<Either<BaseError, UpdateFFmpegProfileResult>>;
-}
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record UpdateFFmpegProfile(
+    int FFmpegProfileId,
+    string Name,
+    int ThreadCount,
+    bool Transcode,
+    HardwareAccelerationKind HardwareAcceleration,
+    VaapiDriver VaapiDriver,
+    string VaapiDevice,
+    int ResolutionId,
+    bool NormalizeVideo,
+    string VideoCodec,
+    int VideoBitrate,
+    int VideoBufferSize,
+    string AudioCodec,
+    int AudioBitrate,
+    int AudioBufferSize,
+    bool NormalizeLoudness,
+    int AudioChannels,
+    int AudioSampleRate,
+    bool NormalizeAudio,
+    bool NormalizeFramerate) : IRequest<Either<BaseError, UpdateFFmpegProfileResult>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs
index 7a65065ee..656496312 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs
@@ -1,87 +1,82 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class
+    UpdateFFmpegProfileHandler : IRequestHandler<UpdateFFmpegProfile, Either<BaseError, UpdateFFmpegProfileResult>>
 {
-    public class
-        UpdateFFmpegProfileHandler : IRequestHandler<UpdateFFmpegProfile, Either<BaseError, UpdateFFmpegProfileResult>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, UpdateFFmpegProfileResult>> Handle(
+        UpdateFFmpegProfile request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdateFFmpegProfileHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, UpdateFFmpegProfileResult>> Handle(
-            UpdateFFmpegProfile request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
-            return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request));
-        }
-
-        private async Task<UpdateFFmpegProfileResult> ApplyUpdateRequest(
-            TvContext dbContext,
-            FFmpegProfile p,
-            UpdateFFmpegProfile update)
-        {
-            p.Name = update.Name;
-            p.ThreadCount = update.ThreadCount;
-            p.Transcode = update.Transcode;
-            p.HardwareAcceleration = update.HardwareAcceleration;
-            p.VaapiDriver = update.VaapiDriver;
-            p.VaapiDevice = update.VaapiDevice;
-            p.ResolutionId = update.ResolutionId;
-            p.NormalizeVideo = update.Transcode && update.NormalizeVideo;
-            p.VideoCodec = update.VideoCodec;
-            p.VideoBitrate = update.VideoBitrate;
-            p.VideoBufferSize = update.VideoBufferSize;
-            p.AudioCodec = update.AudioCodec;
-            p.AudioBitrate = update.AudioBitrate;
-            p.AudioBufferSize = update.AudioBufferSize;
-            p.NormalizeLoudness = update.Transcode && update.NormalizeLoudness;
-            p.AudioChannels = update.AudioChannels;
-            p.AudioSampleRate = update.AudioSampleRate;
-            p.NormalizeAudio = update.Transcode && update.NormalizeAudio;
-            p.NormalizeFramerate = update.Transcode && update.NormalizeFramerate;
-            await dbContext.SaveChangesAsync();
-            return new UpdateFFmpegProfileResult(p.Id);
-        }
-
-        private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
-            TvContext dbContext,
-            UpdateFFmpegProfile request) =>
-            (await FFmpegProfileMustExist(dbContext, request), ValidateName(request), ValidateThreadCount(request),
-                await ResolutionMustExist(dbContext, request))
-            .Apply((ffmpegProfileToUpdate, _, _, _) => ffmpegProfileToUpdate);
-
-        private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
-            TvContext dbContext,
-            UpdateFFmpegProfile updateFFmpegProfile) =>
-            dbContext.FFmpegProfiles
-                .SelectOneAsync(p => p.Id, p => p.Id == updateFFmpegProfile.FFmpegProfileId)
-                .Map(o => o.ToValidation<BaseError>("FFmpegProfile does not exist."));
-
-        private static Validation<BaseError, string> ValidateName(UpdateFFmpegProfile updateFFmpegProfile) =>
-            updateFFmpegProfile.NotEmpty(x => x.Name)
-                .Bind(_ => updateFFmpegProfile.NotLongerThan(50)(x => x.Name));
-
-        private static Validation<BaseError, int> ValidateThreadCount(UpdateFFmpegProfile updateFFmpegProfile) =>
-            updateFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
-
-        private static Task<Validation<BaseError, int>> ResolutionMustExist(
-            TvContext dbContext,
-            UpdateFFmpegProfile updateFFmpegProfile) =>
-            dbContext.Resolutions
-                .SelectOneAsync(r => r.Id, r => r.Id == updateFFmpegProfile.ResolutionId)
-                .MapT(r => r.Id)
-                .Map(o => o.ToValidation<BaseError>($"[Resolution] {updateFFmpegProfile.ResolutionId} does not exist"));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, FFmpegProfile> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, p => ApplyUpdateRequest(dbContext, p, request));
     }
-}
+
+    private async Task<UpdateFFmpegProfileResult> ApplyUpdateRequest(
+        TvContext dbContext,
+        FFmpegProfile p,
+        UpdateFFmpegProfile update)
+    {
+        p.Name = update.Name;
+        p.ThreadCount = update.ThreadCount;
+        p.Transcode = update.Transcode;
+        p.HardwareAcceleration = update.HardwareAcceleration;
+        p.VaapiDriver = update.VaapiDriver;
+        p.VaapiDevice = update.VaapiDevice;
+        p.ResolutionId = update.ResolutionId;
+        p.NormalizeVideo = update.Transcode && update.NormalizeVideo;
+        p.VideoCodec = update.VideoCodec;
+        p.VideoBitrate = update.VideoBitrate;
+        p.VideoBufferSize = update.VideoBufferSize;
+        p.AudioCodec = update.AudioCodec;
+        p.AudioBitrate = update.AudioBitrate;
+        p.AudioBufferSize = update.AudioBufferSize;
+        p.NormalizeLoudness = update.Transcode && update.NormalizeLoudness;
+        p.AudioChannels = update.AudioChannels;
+        p.AudioSampleRate = update.AudioSampleRate;
+        p.NormalizeAudio = update.Transcode && update.NormalizeAudio;
+        p.NormalizeFramerate = update.Transcode && update.NormalizeFramerate;
+        await dbContext.SaveChangesAsync();
+        return new UpdateFFmpegProfileResult(p.Id);
+    }
+
+    private static async Task<Validation<BaseError, FFmpegProfile>> Validate(
+        TvContext dbContext,
+        UpdateFFmpegProfile request) =>
+        (await FFmpegProfileMustExist(dbContext, request), ValidateName(request), ValidateThreadCount(request),
+            await ResolutionMustExist(dbContext, request))
+        .Apply((ffmpegProfileToUpdate, _, _, _) => ffmpegProfileToUpdate);
+
+    private static Task<Validation<BaseError, FFmpegProfile>> FFmpegProfileMustExist(
+        TvContext dbContext,
+        UpdateFFmpegProfile updateFFmpegProfile) =>
+        dbContext.FFmpegProfiles
+            .SelectOneAsync(p => p.Id, p => p.Id == updateFFmpegProfile.FFmpegProfileId)
+            .Map(o => o.ToValidation<BaseError>("FFmpegProfile does not exist."));
+
+    private static Validation<BaseError, string> ValidateName(UpdateFFmpegProfile updateFFmpegProfile) =>
+        updateFFmpegProfile.NotEmpty(x => x.Name)
+            .Bind(_ => updateFFmpegProfile.NotLongerThan(50)(x => x.Name));
+
+    private static Validation<BaseError, int> ValidateThreadCount(UpdateFFmpegProfile updateFFmpegProfile) =>
+        updateFFmpegProfile.AtLeast(0)(p => p.ThreadCount);
+
+    private static Task<Validation<BaseError, int>> ResolutionMustExist(
+        TvContext dbContext,
+        UpdateFFmpegProfile updateFFmpegProfile) =>
+        dbContext.Resolutions
+            .SelectOneAsync(r => r.Id, r => r.Id == updateFFmpegProfile.ResolutionId)
+            .MapT(r => r.Id)
+            .Map(o => o.ToValidation<BaseError>($"[Resolution] {updateFFmpegProfile.ResolutionId} does not exist"));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileResult.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileResult.cs
index c574c6ed0..9fa704174 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileResult.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileResult.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
-{
-    public record UpdateFFmpegProfileResult(int FFmpegProfileId) : EntityIdResult(FFmpegProfileId);
-}
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record UpdateFFmpegProfileResult(int FFmpegProfileId) : EntityIdResult(FFmpegProfileId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettings.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettings.cs
index e4b3b392d..383e0739b 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettings.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettings.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
-{
-    public record UpdateFFmpegSettings(FFmpegSettingsViewModel Settings) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record UpdateFFmpegSettings(FFmpegSettingsViewModel Settings) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs
index bd0bdc3b2..21494dae1 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs
@@ -1,133 +1,128 @@
 using System.Diagnostics;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Commands
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class UpdateFFmpegSettingsHandler : MediatR.IRequestHandler<UpdateFFmpegSettings, Either<BaseError, Unit>>
 {
-    public class UpdateFFmpegSettingsHandler : MediatR.IRequestHandler<UpdateFFmpegSettings, Either<BaseError, Unit>>
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly ILocalFileSystem _localFileSystem;
+
+    public UpdateFFmpegSettingsHandler(
+        IConfigElementRepository configElementRepository,
+        ILocalFileSystem localFileSystem)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly ILocalFileSystem _localFileSystem;
-
-        public UpdateFFmpegSettingsHandler(
-            IConfigElementRepository configElementRepository,
-            ILocalFileSystem localFileSystem)
-        {
-            _configElementRepository = configElementRepository;
-            _localFileSystem = localFileSystem;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdateFFmpegSettings request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(_ => ApplyUpdate(request))
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
-            (await FFmpegMustExist(request), await FFprobeMustExist(request))
-            .Apply((_, _) => Unit.Default);
-
-        private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
-            ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
-
-        private Task<Validation<BaseError, Unit>> FFprobeMustExist(UpdateFFmpegSettings request) =>
-            ValidateToolPath(request.Settings.FFprobePath, "ffprobe");
-
-        private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
-        {
-            if (!_localFileSystem.FileExists(path))
-            {
-                return BaseError.New($"{name} path does not exist");
-            }
-
-            var startInfo = new ProcessStartInfo
-            {
-                FileName = path,
-                Arguments = "-version",
-                RedirectStandardOutput = true,
-                RedirectStandardError = true,
-                UseShellExecute = false
-            };
-
-            var test = new Process
-            {
-                StartInfo = startInfo
-            };
-
-            test.Start();
-            string output = await test.StandardOutput.ReadToEndAsync();
-            await test.WaitForExitAsync();
-            return test.ExitCode == 0 && output.Contains($"{name} version")
-                ? Unit.Default
-                : BaseError.New($"Unable to verify {name} version");
-        }
-
-        private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request)
-        {
-            await _configElementRepository.Upsert(ConfigElementKey.FFmpegPath, request.Settings.FFmpegPath);
-            await _configElementRepository.Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath);
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegDefaultProfileId,
-                request.Settings.DefaultFFmpegProfileId.ToString());
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegSaveReports,
-                request.Settings.SaveReports.ToString());
-
-            if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
-            {
-                Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
-            }
-
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegUseLegacyTranscoder,
-                request.Settings.UseLegacyTranscoder.ToString());
-
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegPreferredLanguageCode,
-                request.Settings.PreferredLanguageCode);
-
-            if (request.Settings.GlobalWatermarkId is not null)
-            {
-                await _configElementRepository.Upsert(
-                    ConfigElementKey.FFmpegGlobalWatermarkId,
-                    request.Settings.GlobalWatermarkId.Value);
-            }
-            else
-            {
-                await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId);
-            }
-
-            if (request.Settings.GlobalFallbackFillerId is not null)
-            {
-                await _configElementRepository.Upsert(
-                    ConfigElementKey.FFmpegGlobalFallbackFillerId,
-                    request.Settings.GlobalFallbackFillerId.Value);
-            }
-            else
-            {
-                await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalFallbackFillerId);
-            }
-
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegSegmenterTimeout,
-                request.Settings.HlsSegmenterIdleTimeout);
-
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegWorkAheadSegmenters,
-                request.Settings.WorkAheadSegmenterLimit);
-
-            await _configElementRepository.Upsert(
-                ConfigElementKey.FFmpegInitialSegmentCount,
-                request.Settings.InitialSegmentCount);
-
-            return Unit.Default;
-        }
+        _configElementRepository = configElementRepository;
+        _localFileSystem = localFileSystem;
     }
-}
+
+    public Task<Either<BaseError, Unit>> Handle(
+        UpdateFFmpegSettings request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(_ => ApplyUpdate(request))
+            .Bind(v => v.ToEitherAsync());
+
+    private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
+        (await FFmpegMustExist(request), await FFprobeMustExist(request))
+        .Apply((_, _) => Unit.Default);
+
+    private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
+        ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
+
+    private Task<Validation<BaseError, Unit>> FFprobeMustExist(UpdateFFmpegSettings request) =>
+        ValidateToolPath(request.Settings.FFprobePath, "ffprobe");
+
+    private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
+    {
+        if (!_localFileSystem.FileExists(path))
+        {
+            return BaseError.New($"{name} path does not exist");
+        }
+
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = path,
+            Arguments = "-version",
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false
+        };
+
+        var test = new Process
+        {
+            StartInfo = startInfo
+        };
+
+        test.Start();
+        string output = await test.StandardOutput.ReadToEndAsync();
+        await test.WaitForExitAsync();
+        return test.ExitCode == 0 && output.Contains($"{name} version")
+            ? Unit.Default
+            : BaseError.New($"Unable to verify {name} version");
+    }
+
+    private async Task<Unit> ApplyUpdate(UpdateFFmpegSettings request)
+    {
+        await _configElementRepository.Upsert(ConfigElementKey.FFmpegPath, request.Settings.FFmpegPath);
+        await _configElementRepository.Upsert(ConfigElementKey.FFprobePath, request.Settings.FFprobePath);
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegDefaultProfileId,
+            request.Settings.DefaultFFmpegProfileId.ToString());
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegSaveReports,
+            request.Settings.SaveReports.ToString());
+
+        if (request.Settings.SaveReports && !Directory.Exists(FileSystemLayout.FFmpegReportsFolder))
+        {
+            Directory.CreateDirectory(FileSystemLayout.FFmpegReportsFolder);
+        }
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegUseLegacyTranscoder,
+            request.Settings.UseLegacyTranscoder.ToString());
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegPreferredLanguageCode,
+            request.Settings.PreferredLanguageCode);
+
+        if (request.Settings.GlobalWatermarkId is not null)
+        {
+            await _configElementRepository.Upsert(
+                ConfigElementKey.FFmpegGlobalWatermarkId,
+                request.Settings.GlobalWatermarkId.Value);
+        }
+        else
+        {
+            await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId);
+        }
+
+        if (request.Settings.GlobalFallbackFillerId is not null)
+        {
+            await _configElementRepository.Upsert(
+                ConfigElementKey.FFmpegGlobalFallbackFillerId,
+                request.Settings.GlobalFallbackFillerId.Value);
+        }
+        else
+        {
+            await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalFallbackFillerId);
+        }
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegSegmenterTimeout,
+            request.Settings.HlsSegmenterIdleTimeout);
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegWorkAheadSegmenters,
+            request.Settings.WorkAheadSegmenterLimit);
+
+        await _configElementRepository.Upsert(
+            ConfigElementKey.FFmpegInitialSegmentCount,
+            request.Settings.InitialSegmentCount);
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs b/ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs
index c30ce3357..4bc68012c 100644
--- a/ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs
@@ -2,27 +2,26 @@
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 
-namespace ErsatzTV.Application.FFmpegProfiles
-{
-    public record FFmpegProfileViewModel(
-        int Id,
-        string Name,
-        int ThreadCount,
-        bool Transcode,
-        HardwareAccelerationKind HardwareAcceleration,
-        VaapiDriver VaapiDriver,
-        string VaapiDevice,
-        ResolutionViewModel Resolution,
-        bool NormalizeVideo,
-        string VideoCodec,
-        int VideoBitrate,
-        int VideoBufferSize,
-        string AudioCodec,
-        int AudioBitrate,
-        int AudioBufferSize,
-        bool NormalizeLoudness,
-        int AudioChannels,
-        int AudioSampleRate,
-        bool NormalizeAudio,
-        bool NormalizeFramerate);
-}
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public record FFmpegProfileViewModel(
+    int Id,
+    string Name,
+    int ThreadCount,
+    bool Transcode,
+    HardwareAccelerationKind HardwareAcceleration,
+    VaapiDriver VaapiDriver,
+    string VaapiDevice,
+    ResolutionViewModel Resolution,
+    bool NormalizeVideo,
+    string VideoCodec,
+    int VideoBitrate,
+    int VideoBufferSize,
+    string AudioCodec,
+    int AudioBitrate,
+    int AudioBufferSize,
+    bool NormalizeLoudness,
+    int AudioChannels,
+    int AudioSampleRate,
+    bool NormalizeAudio,
+    bool NormalizeFramerate);
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs b/ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs
index b06ef54a6..da1a40f84 100644
--- a/ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs
@@ -1,17 +1,16 @@
-namespace ErsatzTV.Application.FFmpegProfiles
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class FFmpegSettingsViewModel
 {
-    public class FFmpegSettingsViewModel
-    {
-        public string FFmpegPath { get; set; }
-        public string FFprobePath { get; set; }
-        public int DefaultFFmpegProfileId { get; set; }
-        public string PreferredLanguageCode { get; set; }
-        public bool SaveReports { get; set; }
-        public int? GlobalWatermarkId { get; set; }
-        public int? GlobalFallbackFillerId { get; set; }
-        public int HlsSegmenterIdleTimeout { get; set; }
-        public int WorkAheadSegmenterLimit { get; set; }
-        public int InitialSegmentCount { get; set; }
-        public bool UseLegacyTranscoder { get; set; }
-    }
-}
+    public string FFmpegPath { get; set; }
+    public string FFprobePath { get; set; }
+    public int DefaultFFmpegProfileId { get; set; }
+    public string PreferredLanguageCode { get; set; }
+    public bool SaveReports { get; set; }
+    public int? GlobalWatermarkId { get; set; }
+    public int? GlobalFallbackFillerId { get; set; }
+    public int HlsSegmenterIdleTimeout { get; set; }
+    public int WorkAheadSegmenterLimit { get; set; }
+    public int InitialSegmentCount { get; set; }
+    public bool UseLegacyTranscoder { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Mapper.cs b/ErsatzTV.Application/FFmpegProfiles/Mapper.cs
index 807cf21cc..a25e07827 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Mapper.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Mapper.cs
@@ -1,34 +1,33 @@
 using ErsatzTV.Application.Resolutions;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.FFmpegProfiles
-{
-    internal static class Mapper
-    {
-        internal static FFmpegProfileViewModel ProjectToViewModel(FFmpegProfile profile) =>
-            new(
-                profile.Id,
-                profile.Name,
-                profile.ThreadCount,
-                profile.Transcode,
-                profile.HardwareAcceleration,
-                profile.VaapiDriver,
-                profile.VaapiDevice,
-                Project(profile.Resolution),
-                profile.NormalizeVideo,
-                profile.VideoCodec,
-                profile.VideoBitrate,
-                profile.VideoBufferSize,
-                profile.AudioCodec,
-                profile.AudioBitrate,
-                profile.AudioBufferSize,
-                profile.NormalizeLoudness,
-                profile.AudioChannels,
-                profile.AudioSampleRate,
-                profile.NormalizeAudio,
-                profile.NormalizeVideo && profile.NormalizeFramerate);
+namespace ErsatzTV.Application.FFmpegProfiles;
 
-        private static ResolutionViewModel Project(Resolution resolution) =>
-            new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);
-    }
-}
+internal static class Mapper
+{
+    internal static FFmpegProfileViewModel ProjectToViewModel(FFmpegProfile profile) =>
+        new(
+            profile.Id,
+            profile.Name,
+            profile.ThreadCount,
+            profile.Transcode,
+            profile.HardwareAcceleration,
+            profile.VaapiDriver,
+            profile.VaapiDevice,
+            Project(profile.Resolution),
+            profile.NormalizeVideo,
+            profile.VideoCodec,
+            profile.VideoBitrate,
+            profile.VideoBufferSize,
+            profile.AudioCodec,
+            profile.AudioBitrate,
+            profile.AudioBufferSize,
+            profile.NormalizeLoudness,
+            profile.AudioChannels,
+            profile.AudioSampleRate,
+            profile.NormalizeAudio,
+            profile.NormalizeVideo && profile.NormalizeFramerate);
+
+    private static ResolutionViewModel Project(Resolution resolution) =>
+        new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfiles.cs b/ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfiles.cs
index 90a3fdba0..7c6e39c3e 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfiles.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfiles.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.FFmpegProfiles;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Queries
-{
-    public record GetAllFFmpegProfiles : IRequest<List<FFmpegProfileViewModel>>;
-}
+public record GetAllFFmpegProfiles : IRequest<List<FFmpegProfileViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfilesHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfilesHandler.cs
index 7a1a6f36f..c0ad5478f 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfilesHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Queries/GetAllFFmpegProfilesHandler.cs
@@ -1,31 +1,24 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Queries
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class GetAllFFmpegProfilesHandler : IRequestHandler<GetAllFFmpegProfiles, List<FFmpegProfileViewModel>>
 {
-    public class GetAllFFmpegProfilesHandler : IRequestHandler<GetAllFFmpegProfiles, List<FFmpegProfileViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllFFmpegProfilesHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<FFmpegProfileViewModel>> Handle(
+        GetAllFFmpegProfiles request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllFFmpegProfilesHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<FFmpegProfileViewModel>> Handle(
-            GetAllFFmpegProfiles request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.FFmpegProfiles
-                .Include(p => p.Resolution)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.FFmpegProfiles
+            .Include(p => p.Resolution)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileById.cs b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileById.cs
index 206a19422..6a5404a73 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileById.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.FFmpegProfiles;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Queries
-{
-    public record GetFFmpegProfileById(int Id) : IRequest<Option<FFmpegProfileViewModel>>;
-}
+public record GetFFmpegProfileById(int Id) : IRequest<Option<FFmpegProfileViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdHandler.cs
index 239412ac8..f17fb3439 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegProfileByIdHandler.cs
@@ -1,30 +1,25 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.FFmpegProfiles.Mapper;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Queries
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class GetFFmpegProfileByIdHandler : IRequestHandler<GetFFmpegProfileById, Option<FFmpegProfileViewModel>>
 {
-    public class GetFFmpegProfileByIdHandler : IRequestHandler<GetFFmpegProfileById, Option<FFmpegProfileViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetFFmpegProfileByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Option<FFmpegProfileViewModel>> Handle(
+        GetFFmpegProfileById request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetFFmpegProfileByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Option<FFmpegProfileViewModel>> Handle(
-            GetFFmpegProfileById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.FFmpegProfiles
-                .Include(p => p.Resolution)
-                .SelectOneAsync(p => p.Id, p => p.Id == request.Id)
-                .MapT(ProjectToViewModel);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.FFmpegProfiles
+            .Include(p => p.Resolution)
+            .SelectOneAsync(p => p.Id, p => p.Id == request.Id)
+            .MapT(ProjectToViewModel);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettings.cs b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettings.cs
index 167b7bf63..db95f2a8e 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettings.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettings.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.FFmpegProfiles;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Queries
-{
-    public record GetFFmpegSettings : IRequest<FFmpegSettingsViewModel>;
-}
+public record GetFFmpegSettings : IRequest<FFmpegSettingsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs
index 73694e2fe..df11fb109 100644
--- a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs
@@ -1,68 +1,63 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.FFmpegProfiles.Queries
+namespace ErsatzTV.Application.FFmpegProfiles;
+
+public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpegSettingsViewModel>
 {
-    public class GetFFmpegSettingsHandler : IRequestHandler<GetFFmpegSettings, FFmpegSettingsViewModel>
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public GetFFmpegSettingsHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<FFmpegSettingsViewModel> Handle(
+        GetFFmpegSettings request,
+        CancellationToken cancellationToken)
     {
-        private readonly IConfigElementRepository _configElementRepository;
+        Option<string> ffmpegPath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath);
+        Option<string> ffprobePath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath);
+        Option<int> defaultFFmpegProfileId =
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId);
+        Option<bool> saveReports =
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
+        Option<string> preferredLanguageCode =
+            await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
+        Option<int> watermark =
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId);
+        Option<int> fallbackFiller =
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalFallbackFillerId);
+        Option<int> hlsSegmenterIdleTimeout =
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout);
+        Option<int> workAheadSegmenterLimit =
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters);
+        Option<int> initialSegmentCount =
+            await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount);
+        Option<bool> useLegacyTranscoder =
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegUseLegacyTranscoder);
 
-        public GetFFmpegSettingsHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
-
-        public async Task<FFmpegSettingsViewModel> Handle(
-            GetFFmpegSettings request,
-            CancellationToken cancellationToken)
+        var result = new FFmpegSettingsViewModel
         {
-            Option<string> ffmpegPath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath);
-            Option<string> ffprobePath = await _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath);
-            Option<int> defaultFFmpegProfileId =
-                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegDefaultProfileId);
-            Option<bool> saveReports =
-                await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
-            Option<string> preferredLanguageCode =
-                await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
-            Option<int> watermark =
-                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId);
-            Option<int> fallbackFiller =
-                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalFallbackFillerId);
-            Option<int> hlsSegmenterIdleTimeout =
-                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout);
-            Option<int> workAheadSegmenterLimit =
-                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters);
-            Option<int> initialSegmentCount =
-                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount);
-            Option<bool> useLegacyTranscoder =
-                await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegUseLegacyTranscoder);
+            FFmpegPath = await ffmpegPath.IfNoneAsync(string.Empty),
+            FFprobePath = await ffprobePath.IfNoneAsync(string.Empty),
+            DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
+            SaveReports = await saveReports.IfNoneAsync(false),
+            PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng"),
+            HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
+            WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),
+            InitialSegmentCount = await initialSegmentCount.IfNoneAsync(1),
+            UseLegacyTranscoder = await useLegacyTranscoder.IfNoneAsync(false)
+        };
 
-            var result = new FFmpegSettingsViewModel
-            {
-                FFmpegPath = await ffmpegPath.IfNoneAsync(string.Empty),
-                FFprobePath = await ffprobePath.IfNoneAsync(string.Empty),
-                DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
-                SaveReports = await saveReports.IfNoneAsync(false),
-                PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng"),
-                HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
-                WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),
-                InitialSegmentCount = await initialSegmentCount.IfNoneAsync(1),
-                UseLegacyTranscoder = await useLegacyTranscoder.IfNoneAsync(false)
-            };
-
-            foreach (int watermarkId in watermark)
-            {
-                result.GlobalWatermarkId = watermarkId;
-            }
-
-            foreach (int fallbackFillerId in fallbackFiller)
-            {
-                result.GlobalFallbackFillerId = fallbackFillerId;
-            }
-
-            return result;
+        foreach (int watermarkId in watermark)
+        {
+            result.GlobalWatermarkId = watermarkId;
         }
+
+        foreach (int fallbackFillerId in fallbackFiller)
+        {
+            result.GlobalFallbackFillerId = fallbackFillerId;
+        }
+
+        return result;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs b/ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs
index c5cf1d70a..aae977fb4 100644
--- a/ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs
+++ b/ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs
@@ -1,24 +1,19 @@
-using System;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Filler.Commands
-{
-    public record CreateFillerPreset(
-        string Name,
-        FillerKind FillerKind,
-        FillerMode FillerMode,
-        TimeSpan? Duration,
-        int? Count,
-        int? PadToNearestMinute,
-        ProgramScheduleItemCollectionType CollectionType,
-        int? CollectionId,
-        int? MediaItemId,
-        int? MultiCollectionId,
-        int? SmartCollectionId
-    ) : IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Filler;
+
+public record CreateFillerPreset(
+    string Name,
+    FillerKind FillerKind,
+    FillerMode FillerMode,
+    TimeSpan? Duration,
+    int? Count,
+    int? PadToNearestMinute,
+    ProgramScheduleItemCollectionType CollectionType,
+    int? CollectionId,
+    int? MediaItemId,
+    int? MultiCollectionId,
+    int? SmartCollectionId
+) : IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs b/ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs
index 2ee14c3f9..86f3540d7 100644
--- a/ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs
+++ b/ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs
@@ -1,55 +1,48 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Filler.Commands
+namespace ErsatzTV.Application.Filler;
+
+public class CreateFillerPresetHandler : IRequestHandler<CreateFillerPreset, Either<BaseError, Unit>>
 {
-    public class CreateFillerPresetHandler : IRequestHandler<CreateFillerPreset, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+    }
 
-        public CreateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
+    public async Task<Either<BaseError, Unit>> Handle(CreateFillerPreset request, CancellationToken cancellationToken)
+    {
+        try
         {
-            _dbContextFactory = dbContextFactory;
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+            var fillerPreset = new FillerPreset
+            {
+                Name = request.Name,
+                FillerKind = request.FillerKind,
+                FillerMode = request.FillerMode,
+                Duration = request.Duration,
+                Count = request.Count,
+                PadToNearestMinute = request.PadToNearestMinute,
+                CollectionType = request.CollectionType,
+                CollectionId = request.CollectionId,
+                MediaItemId = request.MediaItemId,
+                MultiCollectionId = request.MultiCollectionId,
+                SmartCollectionId = request.SmartCollectionId
+            };
+
+            await dbContext.FillerPresets.AddAsync(fillerPreset, cancellationToken);
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            return Unit.Default;
         }
-
-        public async Task<Either<BaseError, Unit>> Handle(CreateFillerPreset request, CancellationToken cancellationToken)
+        catch (Exception ex)
         {
-            try
-            {
-                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-                var fillerPreset = new FillerPreset
-                {
-                    Name = request.Name,
-                    FillerKind = request.FillerKind,
-                    FillerMode = request.FillerMode,
-                    Duration = request.Duration,
-                    Count = request.Count,
-                    PadToNearestMinute = request.PadToNearestMinute,
-                    CollectionType = request.CollectionType,
-                    CollectionId = request.CollectionId,
-                    MediaItemId = request.MediaItemId,
-                    MultiCollectionId = request.MultiCollectionId,
-                    SmartCollectionId = request.SmartCollectionId
-                };
-
-                await dbContext.FillerPresets.AddAsync(fillerPreset, cancellationToken);
-                await dbContext.SaveChangesAsync(cancellationToken);
-
-                return Unit.Default;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
+            return BaseError.New(ex.Message);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Commands/DeleteFillerPreset.cs b/ErsatzTV.Application/Filler/Commands/DeleteFillerPreset.cs
index 69b66bd6b..cd5e64c77 100644
--- a/ErsatzTV.Application/Filler/Commands/DeleteFillerPreset.cs
+++ b/ErsatzTV.Application/Filler/Commands/DeleteFillerPreset.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Filler.Commands
-{
-    public record DeleteFillerPreset(int FillerPresetId) : IRequest<Either<BaseError, LanguageExt.Unit>>;
-}
+namespace ErsatzTV.Application.Filler;
+
+public record DeleteFillerPreset(int FillerPresetId) : IRequest<Either<BaseError, LanguageExt.Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs b/ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs
index 688002f26..0f030bc86 100644
--- a/ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs
+++ b/ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs
@@ -1,43 +1,37 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Filler.Commands
+namespace ErsatzTV.Application.Filler;
+
+public class DeleteFillerPresetHandler : IRequestHandler<DeleteFillerPreset, Either<BaseError, Unit>>
 {
-    public class DeleteFillerPresetHandler : IRequestHandler<DeleteFillerPreset, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeleteFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteFillerPreset request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public DeleteFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteFillerPreset request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
-            return await validation.Apply(ps => DoDeletion(dbContext, ps));
-        }
-
-        private static Task<Unit> DoDeletion(TvContext dbContext, FillerPreset fillerPreset)
-        {
-            dbContext.FillerPresets.Remove(fillerPreset);
-            return dbContext.SaveChangesAsync().ToUnit();
-        }
-
-        private Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
-            TvContext dbContext,
-            DeleteFillerPreset request) =>
-            dbContext.FillerPresets
-                .SelectOneAsync(fp => fp.Id, ps => ps.Id == request.FillerPresetId)
-                .Map(o => o.ToValidation<BaseError>($"FillerPreset {request.FillerPresetId} does not exist."));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, ps => DoDeletion(dbContext, ps));
     }
-}
+
+    private static Task<Unit> DoDeletion(TvContext dbContext, FillerPreset fillerPreset)
+    {
+        dbContext.FillerPresets.Remove(fillerPreset);
+        return dbContext.SaveChangesAsync().ToUnit();
+    }
+
+    private Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
+        TvContext dbContext,
+        DeleteFillerPreset request) =>
+        dbContext.FillerPresets
+            .SelectOneAsync(fp => fp.Id, ps => ps.Id == request.FillerPresetId)
+            .Map(o => o.ToValidation<BaseError>($"FillerPreset {request.FillerPresetId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Commands/UpdateFillerPreset.cs b/ErsatzTV.Application/Filler/Commands/UpdateFillerPreset.cs
index c6c5d8993..01169c5fd 100644
--- a/ErsatzTV.Application/Filler/Commands/UpdateFillerPreset.cs
+++ b/ErsatzTV.Application/Filler/Commands/UpdateFillerPreset.cs
@@ -1,25 +1,20 @@
-using System;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Filler.Commands
-{
-    public record UpdateFillerPreset(
-        int Id,
-        string Name,
-        FillerKind FillerKind,
-        FillerMode FillerMode,
-        TimeSpan? Duration,
-        int? Count,
-        int? PadToNearestMinute,
-        ProgramScheduleItemCollectionType CollectionType,
-        int? CollectionId,
-        int? MediaItemId,
-        int? MultiCollectionId,
-        int? SmartCollectionId
-    ) : IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Filler;
+
+public record UpdateFillerPreset(
+    int Id,
+    string Name,
+    FillerKind FillerKind,
+    FillerMode FillerMode,
+    TimeSpan? Duration,
+    int? Count,
+    int? PadToNearestMinute,
+    ProgramScheduleItemCollectionType CollectionType,
+    int? CollectionId,
+    int? MediaItemId,
+    int? MultiCollectionId,
+    int? SmartCollectionId
+) : IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs b/ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs
index 44a931c7f..30b73f828 100644
--- a/ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs
+++ b/ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs
@@ -1,60 +1,54 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Filler.Commands
+namespace ErsatzTV.Application.Filler;
+
+public class UpdateFillerPresetHandler : IRequestHandler<UpdateFillerPreset, Either<BaseError, Unit>>
 {
-    public class UpdateFillerPresetHandler : IRequestHandler<UpdateFillerPreset, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _dbContextFactory = dbContextFactory;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(UpdateFillerPreset request, CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
-            return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
-        }
-
-        private async Task<Unit> ApplyUpdateRequest(
-            TvContext dbContext,
-            FillerPreset existing,
-            UpdateFillerPreset request)
-        {
-            existing.Name = request.Name;
-            existing.FillerKind = request.FillerKind;
-            existing.FillerMode = request.FillerMode;
-            existing.Duration = request.Duration;
-            existing.Count = request.Count;
-            existing.PadToNearestMinute = request.PadToNearestMinute;
-            existing.CollectionType = request.CollectionType;
-            existing.CollectionId = request.CollectionId;
-            existing.MediaItemId = request.MediaItemId;
-            existing.MultiCollectionId = request.MultiCollectionId;
-            existing.SmartCollectionId = request.SmartCollectionId;
-
-            await dbContext.SaveChangesAsync();
-
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
-            TvContext dbContext,
-            UpdateFillerPreset request) =>
-            dbContext.FillerPresets
-                .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id)
-                .Map(o => o.ToValidation<BaseError>("FillerPreset does not exist"));
+        _dbContextFactory = dbContextFactory;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(UpdateFillerPreset request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, ps => ApplyUpdateRequest(dbContext, ps, request));
+    }
+
+    private async Task<Unit> ApplyUpdateRequest(
+        TvContext dbContext,
+        FillerPreset existing,
+        UpdateFillerPreset request)
+    {
+        existing.Name = request.Name;
+        existing.FillerKind = request.FillerKind;
+        existing.FillerMode = request.FillerMode;
+        existing.Duration = request.Duration;
+        existing.Count = request.Count;
+        existing.PadToNearestMinute = request.PadToNearestMinute;
+        existing.CollectionType = request.CollectionType;
+        existing.CollectionId = request.CollectionId;
+        existing.MediaItemId = request.MediaItemId;
+        existing.MultiCollectionId = request.MultiCollectionId;
+        existing.SmartCollectionId = request.SmartCollectionId;
+
+        await dbContext.SaveChangesAsync();
+
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
+        TvContext dbContext,
+        UpdateFillerPreset request) =>
+        dbContext.FillerPresets
+            .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id)
+            .Map(o => o.ToValidation<BaseError>("FillerPreset does not exist"));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/FillerPresetViewModel.cs b/ErsatzTV.Application/Filler/FillerPresetViewModel.cs
index 34af550c1..383fcade3 100644
--- a/ErsatzTV.Application/Filler/FillerPresetViewModel.cs
+++ b/ErsatzTV.Application/Filler/FillerPresetViewModel.cs
@@ -1,20 +1,18 @@
-using System;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 
-namespace ErsatzTV.Application.Filler
-{
-    public record FillerPresetViewModel(
-        int Id,
-        string Name,
-        FillerKind FillerKind,
-        FillerMode FillerMode,
-        TimeSpan? Duration,
-        int? Count,
-        int? PadToNearestMinute,
-        ProgramScheduleItemCollectionType CollectionType,
-        int? CollectionId,
-        int? MediaItemId,
-        int? MultiCollectionId,
-        int? SmartCollectionId);
-}
+namespace ErsatzTV.Application.Filler;
+
+public record FillerPresetViewModel(
+    int Id,
+    string Name,
+    FillerKind FillerKind,
+    FillerMode FillerMode,
+    TimeSpan? Duration,
+    int? Count,
+    int? PadToNearestMinute,
+    ProgramScheduleItemCollectionType CollectionType,
+    int? CollectionId,
+    int? MediaItemId,
+    int? MultiCollectionId,
+    int? SmartCollectionId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Mapper.cs b/ErsatzTV.Application/Filler/Mapper.cs
index 972e57442..f7ddb8fcf 100644
--- a/ErsatzTV.Application/Filler/Mapper.cs
+++ b/ErsatzTV.Application/Filler/Mapper.cs
@@ -1,22 +1,21 @@
 using ErsatzTV.Core.Domain.Filler;
 
-namespace ErsatzTV.Application.Filler
+namespace ErsatzTV.Application.Filler;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static FillerPresetViewModel ProjectToViewModel(FillerPreset fillerPreset) =>
-            new(
-                fillerPreset.Id,
-                fillerPreset.Name,
-                fillerPreset.FillerKind,
-                fillerPreset.FillerMode,
-                fillerPreset.Duration,
-                fillerPreset.Count,
-                fillerPreset.PadToNearestMinute,
-                fillerPreset.CollectionType,
-                fillerPreset.CollectionId,
-                fillerPreset.MediaItemId,
-                fillerPreset.MultiCollectionId,
-                fillerPreset.SmartCollectionId);
-    }
-}
+    internal static FillerPresetViewModel ProjectToViewModel(FillerPreset fillerPreset) =>
+        new(
+            fillerPreset.Id,
+            fillerPreset.Name,
+            fillerPreset.FillerKind,
+            fillerPreset.FillerMode,
+            fillerPreset.Duration,
+            fillerPreset.Count,
+            fillerPreset.PadToNearestMinute,
+            fillerPreset.CollectionType,
+            fillerPreset.CollectionId,
+            fillerPreset.MediaItemId,
+            fillerPreset.MultiCollectionId,
+            fillerPreset.SmartCollectionId);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/PagedFillerPresetsViewModel.cs b/ErsatzTV.Application/Filler/PagedFillerPresetsViewModel.cs
index ba4efb8f7..fcec726e3 100644
--- a/ErsatzTV.Application/Filler/PagedFillerPresetsViewModel.cs
+++ b/ErsatzTV.Application/Filler/PagedFillerPresetsViewModel.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.Filler;
 
-namespace ErsatzTV.Application.Filler
-{
-    public record PagedFillerPresetsViewModel(int TotalCount, List<FillerPresetViewModel> Page);
-}
+public record PagedFillerPresetsViewModel(int TotalCount, List<FillerPresetViewModel> Page);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Queries/GetAllFillerPresets.cs b/ErsatzTV.Application/Filler/Queries/GetAllFillerPresets.cs
index ef5fff339..2b252f984 100644
--- a/ErsatzTV.Application/Filler/Queries/GetAllFillerPresets.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetAllFillerPresets.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Filler;
 
-namespace ErsatzTV.Application.Filler.Queries
-{
-    public record GetAllFillerPresets : IRequest<List<FillerPresetViewModel>>;
-}
+public record GetAllFillerPresets : IRequest<List<FillerPresetViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsHandler.cs b/ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsHandler.cs
index 5bea7fa1f..de9252b85 100644
--- a/ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsHandler.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsHandler.cs
@@ -1,29 +1,22 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
-using LanguageExt;
 using static ErsatzTV.Application.Filler.Mapper;
 
-namespace ErsatzTV.Application.Filler.Queries
+namespace ErsatzTV.Application.Filler;
+
+public class GetAllFillerPresetsHandler : IRequestHandler<GetAllFillerPresets, List<FillerPresetViewModel>>
 {
-    public class GetAllFillerPresetsHandler : IRequestHandler<GetAllFillerPresets, List<FillerPresetViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<FillerPresetViewModel>> Handle(
+        GetAllFillerPresets request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<FillerPresetViewModel>> Handle(
-            GetAllFillerPresets request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.FillerPresets.ToListAsync(cancellationToken)
-                .Map(presets => presets.Map(ProjectToViewModel).ToList());
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.FillerPresets.ToListAsync(cancellationToken)
+            .Map(presets => presets.Map(ProjectToViewModel).ToList());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Queries/GetFillerPresetById.cs b/ErsatzTV.Application/Filler/Queries/GetFillerPresetById.cs
index 7ab7e8143..2ff167f60 100644
--- a/ErsatzTV.Application/Filler/Queries/GetFillerPresetById.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetFillerPresetById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Filler;
 
-namespace ErsatzTV.Application.Filler.Queries
-{
-    public record GetFillerPresetById(int Id) : IRequest<Option<FillerPresetViewModel>>;
-}
+public record GetFillerPresetById(int Id) : IRequest<Option<FillerPresetViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Queries/GetFillerPresetByIdHandler.cs b/ErsatzTV.Application/Filler/Queries/GetFillerPresetByIdHandler.cs
index 1d6500773..769779e03 100644
--- a/ErsatzTV.Application/Filler/Queries/GetFillerPresetByIdHandler.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetFillerPresetByIdHandler.cs
@@ -1,29 +1,24 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Filler.Mapper;
 
-namespace ErsatzTV.Application.Filler.Queries
+namespace ErsatzTV.Application.Filler;
+
+public class GetFillerPresetByIdHandler : IRequestHandler<GetFillerPresetById, Option<FillerPresetViewModel>>
 {
-    public class GetFillerPresetByIdHandler : IRequestHandler<GetFillerPresetById, Option<FillerPresetViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetFillerPresetByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Option<FillerPresetViewModel>> Handle(
+        GetFillerPresetById request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetFillerPresetByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Option<FillerPresetViewModel>> Handle(
-            GetFillerPresetById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.FillerPresets
-                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
-                .MapT(ProjectToViewModel);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.FillerPresets
+            .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
+            .MapT(ProjectToViewModel);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresets.cs b/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresets.cs
index ed068508c..c3938857a 100644
--- a/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresets.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresets.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.Filler;
 
-namespace ErsatzTV.Application.Filler.Queries
-{
-    public record GetPagedFillerPresets(int PageNum, int PageSize) : IRequest<PagedFillerPresetsViewModel>;
-}
+public record GetPagedFillerPresets(int PageNum, int PageSize) : IRequest<PagedFillerPresetsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs b/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs
index 8bb57db20..279d081de 100644
--- a/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs
@@ -1,46 +1,39 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Infrastructure.Data;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using LanguageExt;
 using static ErsatzTV.Application.Filler.Mapper;
 
-namespace ErsatzTV.Application.Filler.Queries
+namespace ErsatzTV.Application.Filler;
+
+public class GetPagedFillerPresetsHandler : IRequestHandler<GetPagedFillerPresets, PagedFillerPresetsViewModel>
 {
-    public class GetPagedFillerPresetsHandler : IRequestHandler<GetPagedFillerPresets, PagedFillerPresetsViewModel>
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetPagedFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public GetPagedFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<PagedFillerPresetsViewModel> Handle(
+        GetPagedFillerPresets request,
+        CancellationToken cancellationToken)
+    {
+        int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM FillerPreset");
 
-        public async Task<PagedFillerPresetsViewModel> Handle(
-            GetPagedFillerPresets request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM FillerPreset");
-
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<FillerPresetViewModel> page = await dbContext.FillerPresets.FromSqlRaw(
-                    @"SELECT * FROM FillerPreset
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<FillerPresetViewModel> page = await dbContext.FillerPresets.FromSqlRaw(
+                @"SELECT * FROM FillerPreset
                     ORDER BY Name
                     COLLATE NOCASE
                     LIMIT {0} OFFSET {1}",
-                    request.PageSize,
-                    request.PageNum * request.PageSize)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+                request.PageSize,
+                request.PageNum * request.PageSize)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 
-            return new PagedFillerPresetsViewModel(count, page);
-        }
+        return new PagedFillerPresetsViewModel(count, page);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/GlobalUsings.cs b/ErsatzTV.Application/GlobalUsings.cs
new file mode 100644
index 000000000..72fed1436
--- /dev/null
+++ b/ErsatzTV.Application/GlobalUsings.cs
@@ -0,0 +1,5 @@
+global using LanguageExt;
+global using MediatR;
+global using static LanguageExt.Prelude;
+global using Unit = LanguageExt.Unit;
+global using Array = System.Array;
\ No newline at end of file
diff --git a/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCount.cs b/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCount.cs
index 68379df93..b19735ce8 100644
--- a/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCount.cs
+++ b/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCount.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.HDHR.Commands
-{
-    public record UpdateHDHRTunerCount(int TunerCount) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.HDHR;
+
+public record UpdateHDHRTunerCount(int TunerCount) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCountHandler.cs b/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCountHandler.cs
index 6c31ae15e..1b62bfb9a 100644
--- a/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCountHandler.cs
+++ b/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCountHandler.cs
@@ -1,32 +1,27 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.HDHR.Commands
+namespace ErsatzTV.Application.HDHR;
+
+public class UpdateHDHRTunerCountHandler : MediatR.IRequestHandler<UpdateHDHRTunerCount, Either<BaseError, Unit>>
 {
-    public class UpdateHDHRTunerCountHandler : MediatR.IRequestHandler<UpdateHDHRTunerCount, Either<BaseError, Unit>>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
+    private readonly IConfigElementRepository _configElementRepository;
 
-        public UpdateHDHRTunerCountHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+    public UpdateHDHRTunerCountHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
 
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdateHDHRTunerCount request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(_ => _configElementRepository.Upsert(ConfigElementKey.HDHRTunerCount, request.TunerCount.ToString()))
-                .Bind(v => v.ToEitherAsync());
+    public Task<Either<BaseError, Unit>> Handle(
+        UpdateHDHRTunerCount request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(_ => _configElementRepository.Upsert(ConfigElementKey.HDHRTunerCount, request.TunerCount.ToString()))
+            .Bind(v => v.ToEitherAsync());
 
-        private static Task<Validation<BaseError, Unit>> Validate(UpdateHDHRTunerCount request) =>
-            Optional(request.TunerCount)
-                .Where(tc => tc > 0)
-                .Map(_ => Unit.Default)
-                .ToValidation<BaseError>("Tuner count must be greater than zero")
-                .AsTask();
-    }
-}
+    private static Task<Validation<BaseError, Unit>> Validate(UpdateHDHRTunerCount request) =>
+        Optional(request.TunerCount)
+            .Where(tc => tc > 0)
+            .Map(_ => Unit.Default)
+            .ToValidation<BaseError>("Tuner count must be greater than zero")
+            .AsTask();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCount.cs b/ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCount.cs
index 97f242748..79f03b216 100644
--- a/ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCount.cs
+++ b/ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCount.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.HDHR;
 
-namespace ErsatzTV.Application.HDHR.Queries
-{
-    public record GetHDHRTunerCount : IRequest<int>;
-}
+public record GetHDHRTunerCount : IRequest<int>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCountHandler.cs b/ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCountHandler.cs
index e5c3528eb..ef5f4f236 100644
--- a/ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCountHandler.cs
+++ b/ErsatzTV.Application/HDHR/Queries/GetHDHRTunerCountHandler.cs
@@ -1,21 +1,16 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.HDHR.Queries
+namespace ErsatzTV.Application.HDHR;
+
+public class GetHDHRTunerCountHandler : IRequestHandler<GetHDHRTunerCount, int>
 {
-    public class GetHDHRTunerCountHandler : IRequestHandler<GetHDHRTunerCount, int>
-    {
-        private readonly IConfigElementRepository _configElementRepository;
+    private readonly IConfigElementRepository _configElementRepository;
 
-        public GetHDHRTunerCountHandler(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
+    public GetHDHRTunerCountHandler(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
 
-        public Task<int> Handle(GetHDHRTunerCount request, CancellationToken cancellationToken) =>
-            _configElementRepository.GetValue<int>(ConfigElementKey.HDHRTunerCount)
-                .Map(result => result.IfNone(2));
-    }
-}
+    public Task<int> Handle(GetHDHRTunerCount request, CancellationToken cancellationToken) =>
+        _configElementRepository.GetValue<int>(ConfigElementKey.HDHRTunerCount)
+            .Map(result => result.IfNone(2));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs b/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs
index e8fccba0f..269f46489 100644
--- a/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs
+++ b/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs
@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Health;
-using MediatR;
+using ErsatzTV.Core.Health;
 
-namespace ErsatzTV.Application.Health.Queries
-{
-    public record GetAllHealthCheckResults : IRequest<List<HealthCheckResult>>;
-}
+namespace ErsatzTV.Application.Health;
+
+public record GetAllHealthCheckResults : IRequest<List<HealthCheckResult>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs b/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs
index 4aeec64d8..c7ca03423 100644
--- a/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs
+++ b/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs
@@ -1,25 +1,19 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Health;
-using MediatR;
+using ErsatzTV.Core.Health;
 
-namespace ErsatzTV.Application.Health.Queries
+namespace ErsatzTV.Application.Health;
+
+public class GetAllHealthCheckResultsHandler : IRequestHandler<GetAllHealthCheckResults, List<HealthCheckResult>>
 {
-    public class GetAllHealthCheckResultsHandler : IRequestHandler<GetAllHealthCheckResults, List<HealthCheckResult>>
+    private readonly IHealthCheckService _healthCheckService;
+
+    public GetAllHealthCheckResultsHandler(IHealthCheckService healthCheckService) =>
+        _healthCheckService = healthCheckService;
+
+    public async Task<List<HealthCheckResult>> Handle(
+        GetAllHealthCheckResults request,
+        CancellationToken cancellationToken)
     {
-        private readonly IHealthCheckService _healthCheckService;
-
-        public GetAllHealthCheckResultsHandler(IHealthCheckService healthCheckService) =>
-            _healthCheckService = healthCheckService;
-
-        public async Task<List<HealthCheckResult>> Handle(
-            GetAllHealthCheckResults request,
-            CancellationToken cancellationToken)
-        {
-            List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks();
-            return results.Filter(r => r.Status != HealthCheckStatus.NotApplicable).ToList();
-        }
+        List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks();
+        return results.Filter(r => r.Status != HealthCheckStatus.NotApplicable).ToList();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/IBackgroundServiceRequest.cs b/ErsatzTV.Application/IBackgroundServiceRequest.cs
index 7854670db..d86df59a6 100644
--- a/ErsatzTV.Application/IBackgroundServiceRequest.cs
+++ b/ErsatzTV.Application/IBackgroundServiceRequest.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Application
+namespace ErsatzTV.Application;
+
+public interface IBackgroundServiceRequest
 {
-    public interface IBackgroundServiceRequest
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/IEmbyBackgroundServiceRequest.cs b/ErsatzTV.Application/IEmbyBackgroundServiceRequest.cs
index b35664529..766521731 100644
--- a/ErsatzTV.Application/IEmbyBackgroundServiceRequest.cs
+++ b/ErsatzTV.Application/IEmbyBackgroundServiceRequest.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Application
+namespace ErsatzTV.Application;
+
+public interface IEmbyBackgroundServiceRequest
 {
-    public interface IEmbyBackgroundServiceRequest
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/IFFmpegWorkerRequest.cs b/ErsatzTV.Application/IFFmpegWorkerRequest.cs
index 3cc6edf06..a95ac18d8 100644
--- a/ErsatzTV.Application/IFFmpegWorkerRequest.cs
+++ b/ErsatzTV.Application/IFFmpegWorkerRequest.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Application
+namespace ErsatzTV.Application;
+
+public interface IFFmpegWorkerRequest
 {
-    public interface IFFmpegWorkerRequest
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/IJellyfinBackgroundServiceRequest.cs b/ErsatzTV.Application/IJellyfinBackgroundServiceRequest.cs
index d976852ef..b6e844585 100644
--- a/ErsatzTV.Application/IJellyfinBackgroundServiceRequest.cs
+++ b/ErsatzTV.Application/IJellyfinBackgroundServiceRequest.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Application
+namespace ErsatzTV.Application;
+
+public interface IJellyfinBackgroundServiceRequest
 {
-    public interface IJellyfinBackgroundServiceRequest
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/IPlexBackgroundServiceRequest.cs b/ErsatzTV.Application/IPlexBackgroundServiceRequest.cs
index b80ccea84..467bf9bfc 100644
--- a/ErsatzTV.Application/IPlexBackgroundServiceRequest.cs
+++ b/ErsatzTV.Application/IPlexBackgroundServiceRequest.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Application
+namespace ErsatzTV.Application;
+
+public interface IPlexBackgroundServiceRequest
 {
-    public interface IPlexBackgroundServiceRequest
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Images/CachedImagePathViewModel.cs b/ErsatzTV.Application/Images/CachedImagePathViewModel.cs
index bc276043a..0a1f9a1e4 100644
--- a/ErsatzTV.Application/Images/CachedImagePathViewModel.cs
+++ b/ErsatzTV.Application/Images/CachedImagePathViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Images
-{
-    public record CachedImagePathViewModel(string FileName, string MimeType);
-}
+namespace ErsatzTV.Application.Images;
+
+public record CachedImagePathViewModel(string FileName, string MimeType);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Images/Commands/SaveArtworkToDisk.cs b/ErsatzTV.Application/Images/Commands/SaveArtworkToDisk.cs
index c431b7541..3a4b34b92 100644
--- a/ErsatzTV.Application/Images/Commands/SaveArtworkToDisk.cs
+++ b/ErsatzTV.Application/Images/Commands/SaveArtworkToDisk.cs
@@ -1,11 +1,7 @@
-using System.IO;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Images.Commands
-{
-    // ReSharper disable once SuggestBaseTypeForParameter
-    public record SaveArtworkToDisk(Stream Stream, ArtworkKind ArtworkKind) : IRequest<Either<BaseError, string>>;
-}
+namespace ErsatzTV.Application.Images;
+
+// ReSharper disable once SuggestBaseTypeForParameter
+public record SaveArtworkToDisk(Stream Stream, ArtworkKind ArtworkKind) : IRequest<Either<BaseError, string>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Images/Commands/SaveArtworkToDiskHandler.cs b/ErsatzTV.Application/Images/Commands/SaveArtworkToDiskHandler.cs
index dc7caa57d..d4d458957 100644
--- a/ErsatzTV.Application/Images/Commands/SaveArtworkToDiskHandler.cs
+++ b/ErsatzTV.Application/Images/Commands/SaveArtworkToDiskHandler.cs
@@ -1,19 +1,14 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Images;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Images.Commands
+namespace ErsatzTV.Application.Images;
+
+public class SaveArtworkToDiskHandler : IRequestHandler<SaveArtworkToDisk, Either<BaseError, string>>
 {
-    public class SaveArtworkToDiskHandler : IRequestHandler<SaveArtworkToDisk, Either<BaseError, string>>
-    {
-        private readonly IImageCache _imageCache;
+    private readonly IImageCache _imageCache;
 
-        public SaveArtworkToDiskHandler(IImageCache imageCache) => _imageCache = imageCache;
+    public SaveArtworkToDiskHandler(IImageCache imageCache) => _imageCache = imageCache;
 
-        public Task<Either<BaseError, string>> Handle(SaveArtworkToDisk request, CancellationToken cancellationToken) =>
-            _imageCache.SaveArtworkToCache(request.Stream, request.ArtworkKind);
-    }
-}
+    public Task<Either<BaseError, string>> Handle(SaveArtworkToDisk request, CancellationToken cancellationToken) =>
+        _imageCache.SaveArtworkToCache(request.Stream, request.ArtworkKind);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Images/Queries/GetCachedImagePath.cs b/ErsatzTV.Application/Images/Queries/GetCachedImagePath.cs
index f8996757f..ea7d98e20 100644
--- a/ErsatzTV.Application/Images/Queries/GetCachedImagePath.cs
+++ b/ErsatzTV.Application/Images/Queries/GetCachedImagePath.cs
@@ -1,11 +1,8 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Images.Queries
-{
-    public record GetCachedImagePath
-        (string FileName, ArtworkKind ArtworkKind, int? MaxHeight = null) : IRequest<
-            Either<BaseError, CachedImagePathViewModel>>;
-}
+namespace ErsatzTV.Application.Images;
+
+public record GetCachedImagePath
+    (string FileName, ArtworkKind ArtworkKind, int? MaxHeight = null) : IRequest<
+        Either<BaseError, CachedImagePathViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Images/Queries/GetCachedImagePathHandler.cs b/ErsatzTV.Application/Images/Queries/GetCachedImagePathHandler.cs
index a8c6585da..7e845828d 100644
--- a/ErsatzTV.Application/Images/Queries/GetCachedImagePathHandler.cs
+++ b/ErsatzTV.Application/Images/Queries/GetCachedImagePathHandler.cs
@@ -1,72 +1,64 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Images;
-using LanguageExt;
-using MediatR;
 using Winista.Mime;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Images.Queries
+namespace ErsatzTV.Application.Images;
+
+public class
+    GetCachedImagePathHandler : IRequestHandler<GetCachedImagePath, Either<BaseError, CachedImagePathViewModel>>
 {
-    public class
-        GetCachedImagePathHandler : IRequestHandler<GetCachedImagePath, Either<BaseError, CachedImagePathViewModel>>
+    private static readonly MimeTypes MimeTypes = new();
+    private readonly IImageCache _imageCache;
+
+    public GetCachedImagePathHandler(IImageCache imageCache) => _imageCache = imageCache;
+
+    public async Task<Either<BaseError, CachedImagePathViewModel>> Handle(
+        GetCachedImagePath request,
+        CancellationToken cancellationToken)
     {
-        private static readonly MimeTypes MimeTypes = new();
-        private readonly IImageCache _imageCache;
-
-        public GetCachedImagePathHandler(IImageCache imageCache) => _imageCache = imageCache;
-
-        public async Task<Either<BaseError, CachedImagePathViewModel>> Handle(
-            GetCachedImagePath request,
-            CancellationToken cancellationToken)
+        try
         {
-            try
+            MimeType mimeType;
+
+            string cachePath = _imageCache.GetPathForImage(
+                request.FileName,
+                request.ArtworkKind,
+                Optional(request.MaxHeight));
+            if (!File.Exists(cachePath))
             {
-                MimeType mimeType;
-
-                string cachePath = _imageCache.GetPathForImage(
-                    request.FileName,
-                    request.ArtworkKind,
-                    Optional(request.MaxHeight));
-                if (!File.Exists(cachePath))
+                if (request.MaxHeight.HasValue)
                 {
-                    if (request.MaxHeight.HasValue)
+                    string originalPath = _imageCache.GetPathForImage(request.FileName, request.ArtworkKind, None);
+                    byte[] contents = await File.ReadAllBytesAsync(originalPath, cancellationToken);
+                    Either<BaseError, byte[]> resizeResult =
+                        await _imageCache.ResizeImage(contents, request.MaxHeight.Value);
+                    resizeResult.IfRight(result => contents = result);
+
+                    string baseFolder = Path.GetDirectoryName(cachePath);
+                    if (baseFolder != null && !Directory.Exists(baseFolder))
                     {
-                        string originalPath = _imageCache.GetPathForImage(request.FileName, request.ArtworkKind, None);
-                        byte[] contents = await File.ReadAllBytesAsync(originalPath, cancellationToken);
-                        Either<BaseError, byte[]> resizeResult =
-                            await _imageCache.ResizeImage(contents, request.MaxHeight.Value);
-                        resizeResult.IfRight(result => contents = result);
-
-                        string baseFolder = Path.GetDirectoryName(cachePath);
-                        if (baseFolder != null && !Directory.Exists(baseFolder))
-                        {
-                            Directory.CreateDirectory(baseFolder);
-                        }
-
-                        await File.WriteAllBytesAsync(cachePath, contents, cancellationToken);
-
-                        mimeType = new MimeType("image/jpeg");
-                    }
-                    else
-                    {
-                        return BaseError.New($"Artwork does not exist on disk at {cachePath}");
+                        Directory.CreateDirectory(baseFolder);
                     }
+
+                    await File.WriteAllBytesAsync(cachePath, contents, cancellationToken);
+
+                    mimeType = new MimeType("image/jpeg");
                 }
                 else
                 {
-                    mimeType = MimeTypes.GetMimeTypeFromFile(cachePath);
+                    return BaseError.New($"Artwork does not exist on disk at {cachePath}");
                 }
-
-                return new CachedImagePathViewModel(cachePath, mimeType.Name);
             }
-            catch (Exception ex)
+            else
             {
-                return BaseError.New(ex.Message);
+                mimeType = MimeTypes.GetMimeTypeFromFile(cachePath);
             }
+
+            return new CachedImagePathViewModel(cachePath, mimeType.Name);
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfin.cs b/ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfin.cs
index df438ec71..dd651ff51 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfin.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfin.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
-{
-    public record DisconnectJellyfin : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record DisconnectJellyfin : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfinHandler.cs b/ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfinHandler.cs
index 26452d3e4..bb286ac83 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfinHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/DisconnectJellyfinHandler.cs
@@ -1,46 +1,41 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public class DisconnectJellyfinHandler : MediatR.IRequestHandler<DisconnectJellyfin, Either<BaseError, Unit>>
 {
-    public class DisconnectJellyfinHandler : MediatR.IRequestHandler<DisconnectJellyfin, Either<BaseError, Unit>>
+    private readonly IEntityLocker _entityLocker;
+    private readonly IJellyfinSecretStore _jellyfinSecretStore;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public DisconnectJellyfinHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IJellyfinSecretStore jellyfinSecretStore,
+        IEntityLocker entityLocker,
+        ISearchIndex searchIndex)
     {
-        private readonly IEntityLocker _entityLocker;
-        private readonly IJellyfinSecretStore _jellyfinSecretStore;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public DisconnectJellyfinHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IJellyfinSecretStore jellyfinSecretStore,
-            IEntityLocker entityLocker,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _jellyfinSecretStore = jellyfinSecretStore;
-            _entityLocker = entityLocker;
-            _searchIndex = searchIndex;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DisconnectJellyfin request,
-            CancellationToken cancellationToken)
-        {
-            List<int> ids = await _mediaSourceRepository.DeleteAllJellyfin();
-            await _searchIndex.RemoveItems(ids);
-            _searchIndex.Commit();
-            await _jellyfinSecretStore.DeleteAll();
-            _entityLocker.UnlockRemoteMediaSource<JellyfinMediaSource>();
-
-            return Unit.Default;
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _jellyfinSecretStore = jellyfinSecretStore;
+        _entityLocker = entityLocker;
+        _searchIndex = searchIndex;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DisconnectJellyfin request,
+        CancellationToken cancellationToken)
+    {
+        List<int> ids = await _mediaSourceRepository.DeleteAllJellyfin();
+        await _searchIndex.RemoveItems(ids);
+        _searchIndex.Commit();
+        await _jellyfinSecretStore.DeleteAll();
+        _entityLocker.UnlockRemoteMediaSource<JellyfinMediaSource>();
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecrets.cs b/ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecrets.cs
index 024500ac5..bc154cecb 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecrets.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecrets.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
-{
-    public record SaveJellyfinSecrets(JellyfinSecrets Secrets) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record SaveJellyfinSecrets(JellyfinSecrets Secrets) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecretsHandler.cs b/ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecretsHandler.cs
index a00b83f5a..3d6f0226b 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecretsHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SaveJellyfinSecretsHandler.cs
@@ -1,60 +1,56 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public class SaveJellyfinSecretsHandler : MediatR.IRequestHandler<SaveJellyfinSecrets, Either<BaseError, Unit>>
 {
-    public class SaveJellyfinSecretsHandler : MediatR.IRequestHandler<SaveJellyfinSecrets, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IJellyfinBackgroundServiceRequest> _channel;
+    private readonly IJellyfinApiClient _jellyfinApiClient;
+    private readonly IJellyfinSecretStore _jellyfinSecretStore;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public SaveJellyfinSecretsHandler(
+        IJellyfinSecretStore jellyfinSecretStore,
+        IJellyfinApiClient jellyfinApiClient,
+        IMediaSourceRepository mediaSourceRepository,
+        ChannelWriter<IJellyfinBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IJellyfinBackgroundServiceRequest> _channel;
-        private readonly IJellyfinApiClient _jellyfinApiClient;
-        private readonly IJellyfinSecretStore _jellyfinSecretStore;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-
-        public SaveJellyfinSecretsHandler(
-            IJellyfinSecretStore jellyfinSecretStore,
-            IJellyfinApiClient jellyfinApiClient,
-            IMediaSourceRepository mediaSourceRepository,
-            ChannelWriter<IJellyfinBackgroundServiceRequest> channel)
-        {
-            _jellyfinSecretStore = jellyfinSecretStore;
-            _jellyfinApiClient = jellyfinApiClient;
-            _mediaSourceRepository = mediaSourceRepository;
-            _channel = channel;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(SaveJellyfinSecrets request, CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(PerformSave)
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<Validation<BaseError, Parameters>> Validate(SaveJellyfinSecrets request)
-        {
-            Either<BaseError, JellyfinServerInformation> maybeServerInformation = await _jellyfinApiClient
-                .GetServerInformation(request.Secrets.Address, request.Secrets.ApiKey);
-
-            return maybeServerInformation.Match(
-                info => Validation<BaseError, Parameters>.Success(new Parameters(request.Secrets, info)),
-                error => error);
-        }
-
-        private async Task<Unit> PerformSave(Parameters parameters)
-        {
-            await _jellyfinSecretStore.SaveSecrets(parameters.Secrets);
-            await _mediaSourceRepository.UpsertJellyfin(
-                parameters.Secrets.Address,
-                parameters.ServerInformation.ServerName,
-                parameters.ServerInformation.OperatingSystem);
-            await _channel.WriteAsync(new SynchronizeJellyfinMediaSources());
-
-            return Unit.Default;
-        }
-
-        private record Parameters(JellyfinSecrets Secrets, JellyfinServerInformation ServerInformation);
+        _jellyfinSecretStore = jellyfinSecretStore;
+        _jellyfinApiClient = jellyfinApiClient;
+        _mediaSourceRepository = mediaSourceRepository;
+        _channel = channel;
     }
-}
+
+    public Task<Either<BaseError, Unit>> Handle(SaveJellyfinSecrets request, CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(PerformSave)
+            .Bind(v => v.ToEitherAsync());
+
+    private async Task<Validation<BaseError, Parameters>> Validate(SaveJellyfinSecrets request)
+    {
+        Either<BaseError, JellyfinServerInformation> maybeServerInformation = await _jellyfinApiClient
+            .GetServerInformation(request.Secrets.Address, request.Secrets.ApiKey);
+
+        return maybeServerInformation.Match(
+            info => Validation<BaseError, Parameters>.Success(new Parameters(request.Secrets, info)),
+            error => error);
+    }
+
+    private async Task<Unit> PerformSave(Parameters parameters)
+    {
+        await _jellyfinSecretStore.SaveSecrets(parameters.Secrets);
+        await _mediaSourceRepository.UpsertJellyfin(
+            parameters.Secrets.Address,
+            parameters.ServerInformation.ServerName,
+            parameters.ServerInformation.OperatingSystem);
+        await _channel.WriteAsync(new SynchronizeJellyfinMediaSources());
+
+        return Unit.Default;
+    }
+
+    private record Parameters(JellyfinSecrets Secrets, JellyfinServerInformation ServerInformation);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserId.cs b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserId.cs
index ad4563def..f77142258 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserId.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserId.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
-{
-    public record SynchronizeJellyfinAdminUserId(int JellyfinMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
-        IJellyfinBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record SynchronizeJellyfinAdminUserId(int JellyfinMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+    IJellyfinBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs
index fc30c131f..c5d542647 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs
@@ -1,112 +1,107 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public class
+    SynchronizeJellyfinAdminUserIdHandler : MediatR.IRequestHandler<SynchronizeJellyfinAdminUserId,
+        Either<BaseError, Unit>>
 {
-    public class
-        SynchronizeJellyfinAdminUserIdHandler : MediatR.IRequestHandler<SynchronizeJellyfinAdminUserId,
-            Either<BaseError, Unit>>
+    private readonly IJellyfinApiClient _jellyfinApiClient;
+    private readonly IJellyfinSecretStore _jellyfinSecretStore;
+    private readonly ILogger<SynchronizeJellyfinAdminUserIdHandler> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMemoryCache _memoryCache;
+
+    public SynchronizeJellyfinAdminUserIdHandler(
+        IMemoryCache memoryCache,
+        IMediaSourceRepository mediaSourceRepository,
+        IJellyfinSecretStore jellyfinSecretStore,
+        IJellyfinApiClient jellyfinApiClient,
+        ILogger<SynchronizeJellyfinAdminUserIdHandler> logger)
     {
-        private readonly IJellyfinApiClient _jellyfinApiClient;
-        private readonly IJellyfinSecretStore _jellyfinSecretStore;
-        private readonly ILogger<SynchronizeJellyfinAdminUserIdHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMemoryCache _memoryCache;
-
-        public SynchronizeJellyfinAdminUserIdHandler(
-            IMemoryCache memoryCache,
-            IMediaSourceRepository mediaSourceRepository,
-            IJellyfinSecretStore jellyfinSecretStore,
-            IJellyfinApiClient jellyfinApiClient,
-            ILogger<SynchronizeJellyfinAdminUserIdHandler> logger)
-        {
-            _memoryCache = memoryCache;
-            _mediaSourceRepository = mediaSourceRepository;
-            _jellyfinSecretStore = jellyfinSecretStore;
-            _jellyfinApiClient = jellyfinApiClient;
-            _logger = logger;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(
-            SynchronizeJellyfinAdminUserId request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .Map(v => v.ToEither<ConnectionParameters>())
-                .BindT(PerformSync);
-
-        private async Task<Either<BaseError, Unit>> PerformSync(ConnectionParameters parameters)
-        {
-            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{parameters.JellyfinMediaSource.Id}", out string _))
-            {
-                return Unit.Default;
-            }
-
-            Either<BaseError, string> maybeUserId = await _jellyfinApiClient.GetAdminUserId(
-                parameters.ActiveConnection.Address,
-                parameters.ApiKey);
-
-            return await maybeUserId.Match(
-                userId =>
-                {
-                    // _logger.LogDebug("Jellyfin admin user id is {UserId}", userId);
-                    _memoryCache.Set($"jellyfin_admin_user_id.{parameters.JellyfinMediaSource.Id}", userId);
-                    return Task.FromResult<Either<BaseError, Unit>>(Unit.Default);
-                },
-                async error =>
-                {
-                    // clear api key if unable to sync with jellyfin
-                    if (error.Value.Contains("Unauthorized"))
-                    {
-                        await _jellyfinSecretStore.SaveSecrets(
-                            new JellyfinSecrets { Address = parameters.ActiveConnection.Address, ApiKey = null });
-                    }
-
-                    return Left<BaseError, Unit>(error);
-                });
-        }
-
-        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeJellyfinAdminUserId request) =>
-            MediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveApiKey);
-
-        private Task<Validation<BaseError, JellyfinMediaSource>> MediaSourceMustExist(
-            SynchronizeJellyfinAdminUserId request) =>
-            _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
-                .Map(o => o.ToValidation<BaseError>("Jellyfin media source does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            JellyfinMediaSource jellyfinMediaSource)
-        {
-            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
-            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
-                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
-            ConnectionParameters connectionParameters)
-        {
-            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
-            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Where(match => match)
-                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
-                .ToValidation<BaseError>("Jellyfin media source requires an api key");
-        }
-
-        private record ConnectionParameters(
-            JellyfinMediaSource JellyfinMediaSource,
-            JellyfinConnection ActiveConnection)
-        {
-            public string ApiKey { get; set; }
-        }
+        _memoryCache = memoryCache;
+        _mediaSourceRepository = mediaSourceRepository;
+        _jellyfinSecretStore = jellyfinSecretStore;
+        _jellyfinApiClient = jellyfinApiClient;
+        _logger = logger;
     }
-}
+
+    public Task<Either<BaseError, Unit>> Handle(
+        SynchronizeJellyfinAdminUserId request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .Map(v => v.ToEither<ConnectionParameters>())
+            .BindT(PerformSync);
+
+    private async Task<Either<BaseError, Unit>> PerformSync(ConnectionParameters parameters)
+    {
+        if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{parameters.JellyfinMediaSource.Id}", out string _))
+        {
+            return Unit.Default;
+        }
+
+        Either<BaseError, string> maybeUserId = await _jellyfinApiClient.GetAdminUserId(
+            parameters.ActiveConnection.Address,
+            parameters.ApiKey);
+
+        return await maybeUserId.Match(
+            userId =>
+            {
+                // _logger.LogDebug("Jellyfin admin user id is {UserId}", userId);
+                _memoryCache.Set($"jellyfin_admin_user_id.{parameters.JellyfinMediaSource.Id}", userId);
+                return Task.FromResult<Either<BaseError, Unit>>(Unit.Default);
+            },
+            async error =>
+            {
+                // clear api key if unable to sync with jellyfin
+                if (error.Value.Contains("Unauthorized"))
+                {
+                    await _jellyfinSecretStore.SaveSecrets(
+                        new JellyfinSecrets { Address = parameters.ActiveConnection.Address, ApiKey = null });
+                }
+
+                return Left<BaseError, Unit>(error);
+            });
+    }
+
+    private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeJellyfinAdminUserId request) =>
+        MediaSourceMustExist(request)
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveApiKey);
+
+    private Task<Validation<BaseError, JellyfinMediaSource>> MediaSourceMustExist(
+        SynchronizeJellyfinAdminUserId request) =>
+        _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
+            .Map(o => o.ToValidation<BaseError>("Jellyfin media source does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        JellyfinMediaSource jellyfinMediaSource)
+    {
+        Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
+        return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+            .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+    }
+
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+        ConnectionParameters connectionParameters)
+    {
+        JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
+        return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+            .Where(match => match)
+            .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+            .ToValidation<BaseError>("Jellyfin media source requires an api key");
+    }
+
+    private record ConnectionParameters(
+        JellyfinMediaSource JellyfinMediaSource,
+        JellyfinConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraries.cs b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraries.cs
index 422114169..de711cd93 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraries.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraries.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
-{
-    public record SynchronizeJellyfinLibraries(int JellyfinMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
-        IJellyfinBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record SynchronizeJellyfinLibraries(int JellyfinMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+    IJellyfinBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibrariesHandler.cs b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibrariesHandler.cs
index 439250a4f..cf8488879 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibrariesHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibrariesHandler.cs
@@ -1,120 +1,113 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public class
+    SynchronizeJellyfinLibrariesHandler : MediatR.IRequestHandler<SynchronizeJellyfinLibraries,
+        Either<BaseError, Unit>>
+
 {
-    public class
-        SynchronizeJellyfinLibrariesHandler : MediatR.IRequestHandler<SynchronizeJellyfinLibraries,
-            Either<BaseError, Unit>>
+    private readonly IJellyfinApiClient _jellyfinApiClient;
+    private readonly IJellyfinSecretStore _jellyfinSecretStore;
+    private readonly ILogger<SynchronizeJellyfinLibrariesHandler> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
 
+    public SynchronizeJellyfinLibrariesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IJellyfinSecretStore jellyfinSecretStore,
+        IJellyfinApiClient jellyfinApiClient,
+        ILogger<SynchronizeJellyfinLibrariesHandler> logger,
+        ISearchIndex searchIndex)
     {
-        private readonly IJellyfinApiClient _jellyfinApiClient;
-        private readonly IJellyfinSecretStore _jellyfinSecretStore;
-        private readonly ILogger<SynchronizeJellyfinLibrariesHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public SynchronizeJellyfinLibrariesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IJellyfinSecretStore jellyfinSecretStore,
-            IJellyfinApiClient jellyfinApiClient,
-            ILogger<SynchronizeJellyfinLibrariesHandler> logger,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _jellyfinSecretStore = jellyfinSecretStore;
-            _jellyfinApiClient = jellyfinApiClient;
-            _logger = logger;
-            _searchIndex = searchIndex;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(
-            SynchronizeJellyfinLibraries request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(SynchronizeLibraries)
-                .Bind(v => v.ToEitherAsync());
-
-        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeJellyfinLibraries request) =>
-            MediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveApiKey);
-
-        private Task<Validation<BaseError, JellyfinMediaSource>> MediaSourceMustExist(
-            SynchronizeJellyfinLibraries request) =>
-            _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
-                .Map(o => o.ToValidation<BaseError>("Jellyfin media source does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            JellyfinMediaSource jellyfinMediaSource)
-        {
-            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
-            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
-                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
-            ConnectionParameters connectionParameters)
-        {
-            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
-            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Where(match => match)
-                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
-                .ToValidation<BaseError>("Jellyfin media source requires an api key");
-        }
-
-        private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
-        {
-            Either<BaseError, List<JellyfinLibrary>> maybeLibraries = await _jellyfinApiClient.GetLibraries(
-                connectionParameters.ActiveConnection.Address,
-                connectionParameters.ApiKey);
-
-            await maybeLibraries.Match(
-                async libraries =>
-                {
-                    var existing = connectionParameters.JellyfinMediaSource.Libraries.OfType<JellyfinLibrary>()
-                        .ToList();
-                    var toAdd = libraries.Filter(library => existing.All(l => l.ItemId != library.ItemId)).ToList();
-                    var toRemove = existing.Filter(library => libraries.All(l => l.ItemId != library.ItemId)).ToList();
-                    List<int> ids = await _mediaSourceRepository.UpdateLibraries(
-                        connectionParameters.JellyfinMediaSource.Id,
-                        toAdd,
-                        toRemove);
-                    if (ids.Any())
-                    {
-                        await _searchIndex.RemoveItems(ids);
-                        _searchIndex.Commit();
-                    }
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Unable to synchronize libraries from jellyfin server {JellyfinServer}: {Error}",
-                        connectionParameters.JellyfinMediaSource.ServerName,
-                        error.Value);
-
-                    return Task.CompletedTask;
-                });
-
-            return Unit.Default;
-        }
-
-        private record ConnectionParameters(
-            JellyfinMediaSource JellyfinMediaSource,
-            JellyfinConnection ActiveConnection)
-        {
-            public string ApiKey { get; set; }
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _jellyfinSecretStore = jellyfinSecretStore;
+        _jellyfinApiClient = jellyfinApiClient;
+        _logger = logger;
+        _searchIndex = searchIndex;
     }
-}
+
+    public Task<Either<BaseError, Unit>> Handle(
+        SynchronizeJellyfinLibraries request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(SynchronizeLibraries)
+            .Bind(v => v.ToEitherAsync());
+
+    private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizeJellyfinLibraries request) =>
+        MediaSourceMustExist(request)
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveApiKey);
+
+    private Task<Validation<BaseError, JellyfinMediaSource>> MediaSourceMustExist(
+        SynchronizeJellyfinLibraries request) =>
+        _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
+            .Map(o => o.ToValidation<BaseError>("Jellyfin media source does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        JellyfinMediaSource jellyfinMediaSource)
+    {
+        Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
+        return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+            .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+    }
+
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+        ConnectionParameters connectionParameters)
+    {
+        JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
+        return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+            .Where(match => match)
+            .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+            .ToValidation<BaseError>("Jellyfin media source requires an api key");
+    }
+
+    private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
+    {
+        Either<BaseError, List<JellyfinLibrary>> maybeLibraries = await _jellyfinApiClient.GetLibraries(
+            connectionParameters.ActiveConnection.Address,
+            connectionParameters.ApiKey);
+
+        await maybeLibraries.Match(
+            async libraries =>
+            {
+                var existing = connectionParameters.JellyfinMediaSource.Libraries.OfType<JellyfinLibrary>()
+                    .ToList();
+                var toAdd = libraries.Filter(library => existing.All(l => l.ItemId != library.ItemId)).ToList();
+                var toRemove = existing.Filter(library => libraries.All(l => l.ItemId != library.ItemId)).ToList();
+                List<int> ids = await _mediaSourceRepository.UpdateLibraries(
+                    connectionParameters.JellyfinMediaSource.Id,
+                    toAdd,
+                    toRemove);
+                if (ids.Any())
+                {
+                    await _searchIndex.RemoveItems(ids);
+                    _searchIndex.Commit();
+                }
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Unable to synchronize libraries from jellyfin server {JellyfinServer}: {Error}",
+                    connectionParameters.JellyfinMediaSource.ServerName,
+                    error.Value);
+
+                return Task.CompletedTask;
+            });
+
+        return Unit.Default;
+    }
+
+    private record ConnectionParameters(
+        JellyfinMediaSource JellyfinMediaSource,
+        JellyfinConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryById.cs b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryById.cs
index 8dbf89f15..926d25733 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryById.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryById.cs
@@ -1,23 +1,20 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public interface ISynchronizeJellyfinLibraryById : IRequest<Either<BaseError, string>>,
+    IJellyfinBackgroundServiceRequest
 {
-    public interface ISynchronizeJellyfinLibraryById : IRequest<Either<BaseError, string>>,
-        IJellyfinBackgroundServiceRequest
-    {
-        int JellyfinLibraryId { get; }
-        bool ForceScan { get; }
-    }
-
-    public record SynchronizeJellyfinLibraryByIdIfNeeded(int JellyfinLibraryId) : ISynchronizeJellyfinLibraryById
-    {
-        public bool ForceScan => false;
-    }
-
-    public record ForceSynchronizeJellyfinLibraryById(int JellyfinLibraryId) : ISynchronizeJellyfinLibraryById
-    {
-        public bool ForceScan => true;
-    }
+    int JellyfinLibraryId { get; }
+    bool ForceScan { get; }
 }
+
+public record SynchronizeJellyfinLibraryByIdIfNeeded(int JellyfinLibraryId) : ISynchronizeJellyfinLibraryById
+{
+    public bool ForceScan => false;
+}
+
+public record ForceSynchronizeJellyfinLibraryById(int JellyfinLibraryId) : ISynchronizeJellyfinLibraryById
+{
+    public bool ForceScan => true;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs
index 25d8abc18..3348dfd5b 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs
@@ -1,181 +1,172 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public class SynchronizeJellyfinLibraryByIdHandler :
+    IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>,
+    IRequestHandler<SynchronizeJellyfinLibraryByIdIfNeeded, Either<BaseError, string>>
 {
-    public class SynchronizeJellyfinLibraryByIdHandler :
-        IRequestHandler<ForceSynchronizeJellyfinLibraryById, Either<BaseError, string>>,
-        IRequestHandler<SynchronizeJellyfinLibraryByIdIfNeeded, Either<BaseError, string>>
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly IEntityLocker _entityLocker;
+    private readonly IJellyfinMovieLibraryScanner _jellyfinMovieLibraryScanner;
+
+    private readonly IJellyfinSecretStore _jellyfinSecretStore;
+    private readonly IJellyfinTelevisionLibraryScanner _jellyfinTelevisionLibraryScanner;
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILogger<SynchronizeJellyfinLibraryByIdHandler> _logger;
+
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public SynchronizeJellyfinLibraryByIdHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IJellyfinSecretStore jellyfinSecretStore,
+        IJellyfinMovieLibraryScanner jellyfinMovieLibraryScanner,
+        IJellyfinTelevisionLibraryScanner jellyfinTelevisionLibraryScanner,
+        ILibraryRepository libraryRepository,
+        IEntityLocker entityLocker,
+        IConfigElementRepository configElementRepository,
+        ILogger<SynchronizeJellyfinLibraryByIdHandler> logger)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly IEntityLocker _entityLocker;
-        private readonly IJellyfinMovieLibraryScanner _jellyfinMovieLibraryScanner;
-
-        private readonly IJellyfinSecretStore _jellyfinSecretStore;
-        private readonly IJellyfinTelevisionLibraryScanner _jellyfinTelevisionLibraryScanner;
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILogger<SynchronizeJellyfinLibraryByIdHandler> _logger;
-
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-
-        public SynchronizeJellyfinLibraryByIdHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IJellyfinSecretStore jellyfinSecretStore,
-            IJellyfinMovieLibraryScanner jellyfinMovieLibraryScanner,
-            IJellyfinTelevisionLibraryScanner jellyfinTelevisionLibraryScanner,
-            ILibraryRepository libraryRepository,
-            IEntityLocker entityLocker,
-            IConfigElementRepository configElementRepository,
-            ILogger<SynchronizeJellyfinLibraryByIdHandler> logger)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _jellyfinSecretStore = jellyfinSecretStore;
-            _jellyfinMovieLibraryScanner = jellyfinMovieLibraryScanner;
-            _jellyfinTelevisionLibraryScanner = jellyfinTelevisionLibraryScanner;
-            _libraryRepository = libraryRepository;
-            _entityLocker = entityLocker;
-            _configElementRepository = configElementRepository;
-            _logger = logger;
-        }
-
-        public Task<Either<BaseError, string>> Handle(
-            ForceSynchronizeJellyfinLibraryById request,
-            CancellationToken cancellationToken) => Handle(request);
-
-        public Task<Either<BaseError, string>> Handle(
-            SynchronizeJellyfinLibraryByIdIfNeeded request,
-            CancellationToken cancellationToken) => Handle(request);
-
-        private Task<Either<BaseError, string>>
-            Handle(ISynchronizeJellyfinLibraryById request) =>
-            Validate(request)
-                .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<Unit> Synchronize(RequestParameters parameters)
-        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
-            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
-            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
-            {
-                switch (parameters.Library.MediaKind)
-                {
-                    case LibraryMediaKind.Movies:
-                        await _jellyfinMovieLibraryScanner.ScanLibrary(
-                            parameters.ConnectionParameters.ActiveConnection.Address,
-                            parameters.ConnectionParameters.ApiKey,
-                            parameters.Library,
-                            parameters.FFprobePath);
-                        break;
-                    case LibraryMediaKind.Shows:
-                        await _jellyfinTelevisionLibraryScanner.ScanLibrary(
-                            parameters.ConnectionParameters.ActiveConnection.Address,
-                            parameters.ConnectionParameters.ApiKey,
-                            parameters.Library,
-                            parameters.FFprobePath);
-                        break;
-                }
-
-                parameters.Library.LastScan = DateTime.UtcNow;
-                await _libraryRepository.UpdateLastScan(parameters.Library);
-            }
-            else
-            {
-                _logger.LogDebug(
-                    "Skipping unforced scan of jellyfin media library {Name}",
-                    parameters.Library.Name);
-            }
-
-            _entityLocker.UnlockLibrary(parameters.Library.Id);
-            return Unit.Default;
-        }
-
-        private async Task<Validation<BaseError, RequestParameters>> Validate(
-            ISynchronizeJellyfinLibraryById request) =>
-            (await ValidateConnection(request), await JellyfinLibraryMustExist(request),
-                await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
-            .Apply(
-                (connectionParameters, jellyfinLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
-                    connectionParameters,
-                    jellyfinLibrary,
-                    request.ForceScan,
-                    libraryRefreshInterval,
-                    ffprobePath
-                ));
-
-        private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
-            ISynchronizeJellyfinLibraryById request) =>
-            JellyfinMediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveApiKey);
-
-        private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist(
-            ISynchronizeJellyfinLibraryById request) =>
-            _mediaSourceRepository.GetJellyfinByLibraryId(request.JellyfinLibraryId)
-                .Map(
-                    v => v.ToValidation<BaseError>(
-                        $"Jellyfin media source for library {request.JellyfinLibraryId} does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            JellyfinMediaSource jellyfinMediaSource)
-        {
-            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
-            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
-                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
-            ConnectionParameters connectionParameters)
-        {
-            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
-            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Where(match => match)
-                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
-                .ToValidation<BaseError>("Jellyfin media source requires an api key");
-        }
-
-        private Task<Validation<BaseError, JellyfinLibrary>> JellyfinLibraryMustExist(
-            ISynchronizeJellyfinLibraryById request) =>
-            _mediaSourceRepository.GetJellyfinLibrary(request.JellyfinLibraryId)
-                .Map(v => v.ToValidation<BaseError>($"Jellyfin library {request.JellyfinLibraryId} does not exist."));
-
-        private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
-            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
-                .FilterT(lri => lri > 0)
-                .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
-
-        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
-            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
-                .FilterT(File.Exists)
-                .Map(
-                    ffprobePath =>
-                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
-
-        private record RequestParameters(
-            ConnectionParameters ConnectionParameters,
-            JellyfinLibrary Library,
-            bool ForceScan,
-            int LibraryRefreshInterval,
-            string FFprobePath);
-
-        private record ConnectionParameters(
-            JellyfinMediaSource JellyfinMediaSource,
-            JellyfinConnection ActiveConnection)
-        {
-            public string ApiKey { get; set; }
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _jellyfinSecretStore = jellyfinSecretStore;
+        _jellyfinMovieLibraryScanner = jellyfinMovieLibraryScanner;
+        _jellyfinTelevisionLibraryScanner = jellyfinTelevisionLibraryScanner;
+        _libraryRepository = libraryRepository;
+        _entityLocker = entityLocker;
+        _configElementRepository = configElementRepository;
+        _logger = logger;
     }
-}
+
+    public Task<Either<BaseError, string>> Handle(
+        ForceSynchronizeJellyfinLibraryById request,
+        CancellationToken cancellationToken) => Handle(request);
+
+    public Task<Either<BaseError, string>> Handle(
+        SynchronizeJellyfinLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request);
+
+    private Task<Either<BaseError, string>>
+        Handle(ISynchronizeJellyfinLibraryById request) =>
+        Validate(request)
+            .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
+            .Bind(v => v.ToEitherAsync());
+
+    private async Task<Unit> Synchronize(RequestParameters parameters)
+    {
+        var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
+        if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
+        {
+            switch (parameters.Library.MediaKind)
+            {
+                case LibraryMediaKind.Movies:
+                    await _jellyfinMovieLibraryScanner.ScanLibrary(
+                        parameters.ConnectionParameters.ActiveConnection.Address,
+                        parameters.ConnectionParameters.ApiKey,
+                        parameters.Library,
+                        parameters.FFprobePath);
+                    break;
+                case LibraryMediaKind.Shows:
+                    await _jellyfinTelevisionLibraryScanner.ScanLibrary(
+                        parameters.ConnectionParameters.ActiveConnection.Address,
+                        parameters.ConnectionParameters.ApiKey,
+                        parameters.Library,
+                        parameters.FFprobePath);
+                    break;
+            }
+
+            parameters.Library.LastScan = DateTime.UtcNow;
+            await _libraryRepository.UpdateLastScan(parameters.Library);
+        }
+        else
+        {
+            _logger.LogDebug(
+                "Skipping unforced scan of jellyfin media library {Name}",
+                parameters.Library.Name);
+        }
+
+        _entityLocker.UnlockLibrary(parameters.Library.Id);
+        return Unit.Default;
+    }
+
+    private async Task<Validation<BaseError, RequestParameters>> Validate(
+        ISynchronizeJellyfinLibraryById request) =>
+        (await ValidateConnection(request), await JellyfinLibraryMustExist(request),
+            await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
+        .Apply(
+            (connectionParameters, jellyfinLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
+                connectionParameters,
+                jellyfinLibrary,
+                request.ForceScan,
+                libraryRefreshInterval,
+                ffprobePath
+            ));
+
+    private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
+        ISynchronizeJellyfinLibraryById request) =>
+        JellyfinMediaSourceMustExist(request)
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveApiKey);
+
+    private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist(
+        ISynchronizeJellyfinLibraryById request) =>
+        _mediaSourceRepository.GetJellyfinByLibraryId(request.JellyfinLibraryId)
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    $"Jellyfin media source for library {request.JellyfinLibraryId} does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        JellyfinMediaSource jellyfinMediaSource)
+    {
+        Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.HeadOrNone();
+        return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+            .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+    }
+
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveApiKey(
+        ConnectionParameters connectionParameters)
+    {
+        JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
+        return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
+            .Where(match => match)
+            .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
+            .ToValidation<BaseError>("Jellyfin media source requires an api key");
+    }
+
+    private Task<Validation<BaseError, JellyfinLibrary>> JellyfinLibraryMustExist(
+        ISynchronizeJellyfinLibraryById request) =>
+        _mediaSourceRepository.GetJellyfinLibrary(request.JellyfinLibraryId)
+            .Map(v => v.ToValidation<BaseError>($"Jellyfin library {request.JellyfinLibraryId} does not exist."));
+
+    private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
+        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+            .FilterT(lri => lri > 0)
+            .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
+
+    private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
+        _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
+            .FilterT(File.Exists)
+            .Map(
+                ffprobePath =>
+                    ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
+
+    private record RequestParameters(
+        ConnectionParameters ConnectionParameters,
+        JellyfinLibrary Library,
+        bool ForceScan,
+        int LibraryRefreshInterval,
+        string FFprobePath);
+
+    private record ConnectionParameters(
+        JellyfinMediaSource JellyfinMediaSource,
+        JellyfinConnection ActiveConnection)
+    {
+        public string ApiKey { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSources.cs b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSources.cs
index ccd67e35b..9ae409b00 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSources.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSources.cs
@@ -1,11 +1,7 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
-{
-    public record SynchronizeJellyfinMediaSources : IRequest<Either<BaseError, List<JellyfinMediaSource>>>,
-        IJellyfinBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record SynchronizeJellyfinMediaSources : IRequest<Either<BaseError, List<JellyfinMediaSource>>>,
+    IJellyfinBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSourcesHandler.cs b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSourcesHandler.cs
index 0677c86e6..4171335ed 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSourcesHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinMediaSourcesHandler.cs
@@ -1,41 +1,35 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public class SynchronizeJellyfinMediaSourcesHandler : IRequestHandler<SynchronizeJellyfinMediaSources,
+    Either<BaseError, List<JellyfinMediaSource>>>
 {
-    public class SynchronizeJellyfinMediaSourcesHandler : IRequestHandler<SynchronizeJellyfinMediaSources,
-        Either<BaseError, List<JellyfinMediaSource>>>
+    private readonly ChannelWriter<IJellyfinBackgroundServiceRequest> _channel;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public SynchronizeJellyfinMediaSourcesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        ChannelWriter<IJellyfinBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IJellyfinBackgroundServiceRequest> _channel;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-
-        public SynchronizeJellyfinMediaSourcesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            ChannelWriter<IJellyfinBackgroundServiceRequest> channel)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, List<JellyfinMediaSource>>> Handle(
-            SynchronizeJellyfinMediaSources request,
-            CancellationToken cancellationToken)
-        {
-            List<JellyfinMediaSource> mediaSources = await _mediaSourceRepository.GetAllJellyfin();
-            foreach (JellyfinMediaSource mediaSource in mediaSources)
-            {
-                await _channel.WriteAsync(new SynchronizeJellyfinAdminUserId(mediaSource.Id), cancellationToken);
-                await _channel.WriteAsync(new SynchronizeJellyfinLibraries(mediaSource.Id), cancellationToken);
-            }
-
-            return mediaSources;
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, List<JellyfinMediaSource>>> Handle(
+        SynchronizeJellyfinMediaSources request,
+        CancellationToken cancellationToken)
+    {
+        List<JellyfinMediaSource> mediaSources = await _mediaSourceRepository.GetAllJellyfin();
+        foreach (JellyfinMediaSource mediaSource in mediaSources)
+        {
+            await _channel.WriteAsync(new SynchronizeJellyfinAdminUserId(mediaSource.Id), cancellationToken);
+            await _channel.WriteAsync(new SynchronizeJellyfinLibraries(mediaSource.Id), cancellationToken);
+        }
+
+        return mediaSources;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferences.cs b/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferences.cs
index 64fe8ad27..655dee6df 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferences.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferences.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
-{
-    public record UpdateJellyfinLibraryPreferences
-        (List<JellyfinLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+namespace ErsatzTV.Application.Jellyfin;
 
-    public record JellyfinLibraryPreference(int Id, bool ShouldSyncItems);
-}
+public record UpdateJellyfinLibraryPreferences
+    (List<JellyfinLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+public record JellyfinLibraryPreference(int Id, bool ShouldSyncItems);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferencesHandler.cs b/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferencesHandler.cs
index 4060af789..0748af034 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferencesHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinLibraryPreferencesHandler.cs
@@ -1,42 +1,36 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public class
+    UpdateJellyfinLibraryPreferencesHandler : MediatR.IRequestHandler<UpdateJellyfinLibraryPreferences,
+        Either<BaseError, Unit>>
 {
-    public class
-        UpdateJellyfinLibraryPreferencesHandler : MediatR.IRequestHandler<UpdateJellyfinLibraryPreferences,
-            Either<BaseError, Unit>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public UpdateJellyfinLibraryPreferencesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        ISearchIndex searchIndex)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public UpdateJellyfinLibraryPreferencesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _searchIndex = searchIndex;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            UpdateJellyfinLibraryPreferences request,
-            CancellationToken cancellationToken)
-        {
-            var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
-            List<int> ids = await _mediaSourceRepository.DisableJellyfinLibrarySync(toDisable);
-            await _searchIndex.RemoveItems(ids);
-            _searchIndex.Commit();
-
-            IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
-            await _mediaSourceRepository.EnableJellyfinLibrarySync(toEnable);
-
-            return Unit.Default;
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _searchIndex = searchIndex;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateJellyfinLibraryPreferences request,
+        CancellationToken cancellationToken)
+    {
+        var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
+        List<int> ids = await _mediaSourceRepository.DisableJellyfinLibrarySync(toDisable);
+        await _searchIndex.RemoveItems(ids);
+        _searchIndex.Commit();
+
+        IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
+        await _mediaSourceRepository.EnableJellyfinLibrarySync(toEnable);
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacements.cs b/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacements.cs
index 0fb94474e..b17b3aa2a 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacements.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacements.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
-{
-    public record UpdateJellyfinPathReplacements(
-        int JellyfinMediaSourceId,
-        List<JellyfinPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+namespace ErsatzTV.Application.Jellyfin;
 
-    public record JellyfinPathReplacementItem(int Id, string JellyfinPath, string LocalPath);
-}
+public record UpdateJellyfinPathReplacements(
+    int JellyfinMediaSourceId,
+    List<JellyfinPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+public record JellyfinPathReplacementItem(int Id, string JellyfinPath, string LocalPath);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacementsHandler.cs b/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacementsHandler.cs
index 3d4877a0c..dbf45f68b 100644
--- a/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacementsHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/UpdateJellyfinPathReplacementsHandler.cs
@@ -1,55 +1,49 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Jellyfin.Commands
+namespace ErsatzTV.Application.Jellyfin;
+
+public class UpdateJellyfinPathReplacementsHandler : MediatR.IRequestHandler<UpdateJellyfinPathReplacements,
+    Either<BaseError, Unit>>
 {
-    public class UpdateJellyfinPathReplacementsHandler : MediatR.IRequestHandler<UpdateJellyfinPathReplacements,
-        Either<BaseError, Unit>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public UpdateJellyfinPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
+
+    public Task<Either<BaseError, Unit>> Handle(
+        UpdateJellyfinPathReplacements request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(pms => MergePathReplacements(request, pms))
+            .Bind(v => v.ToEitherAsync());
+
+    private Task<Unit> MergePathReplacements(
+        UpdateJellyfinPathReplacements request,
+        JellyfinMediaSource jellyfinMediaSource)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        jellyfinMediaSource.PathReplacements ??= new List<JellyfinPathReplacement>();
 
-        public UpdateJellyfinPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+        var incoming = request.PathReplacements.Map(Project).ToList();
 
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdateJellyfinPathReplacements request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(pms => MergePathReplacements(request, pms))
-                .Bind(v => v.ToEitherAsync());
+        var toAdd = incoming.Filter(r => r.Id < 1).ToList();
+        var toRemove = jellyfinMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
+        var toUpdate = incoming.Except(toAdd).ToList();
 
-        private Task<Unit> MergePathReplacements(
-            UpdateJellyfinPathReplacements request,
-            JellyfinMediaSource jellyfinMediaSource)
-        {
-            jellyfinMediaSource.PathReplacements ??= new List<JellyfinPathReplacement>();
-
-            var incoming = request.PathReplacements.Map(Project).ToList();
-
-            var toAdd = incoming.Filter(r => r.Id < 1).ToList();
-            var toRemove = jellyfinMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
-            var toUpdate = incoming.Except(toAdd).ToList();
-
-            return _mediaSourceRepository.UpdatePathReplacements(jellyfinMediaSource.Id, toAdd, toUpdate, toRemove);
-        }
-
-        private static JellyfinPathReplacement Project(JellyfinPathReplacementItem vm) =>
-            new() { Id = vm.Id, JellyfinPath = vm.JellyfinPath, LocalPath = vm.LocalPath };
-
-        private Task<Validation<BaseError, JellyfinMediaSource>> Validate(UpdateJellyfinPathReplacements request) =>
-            JellyfinMediaSourceMustExist(request);
-
-        private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist(
-            UpdateJellyfinPathReplacements request) =>
-            _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
-                .Map(
-                    v => v.ToValidation<BaseError>(
-                        $"Jellyfin media source {request.JellyfinMediaSourceId} does not exist."));
+        return _mediaSourceRepository.UpdatePathReplacements(jellyfinMediaSource.Id, toAdd, toUpdate, toRemove);
     }
-}
+
+    private static JellyfinPathReplacement Project(JellyfinPathReplacementItem vm) =>
+        new() { Id = vm.Id, JellyfinPath = vm.JellyfinPath, LocalPath = vm.LocalPath };
+
+    private Task<Validation<BaseError, JellyfinMediaSource>> Validate(UpdateJellyfinPathReplacements request) =>
+        JellyfinMediaSourceMustExist(request);
+
+    private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist(
+        UpdateJellyfinPathReplacements request) =>
+        _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId)
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    $"Jellyfin media source {request.JellyfinMediaSourceId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/JellyfinConnectionParametersViewModel.cs b/ErsatzTV.Application/Jellyfin/JellyfinConnectionParametersViewModel.cs
index 2ad489515..50592c61a 100644
--- a/ErsatzTV.Application/Jellyfin/JellyfinConnectionParametersViewModel.cs
+++ b/ErsatzTV.Application/Jellyfin/JellyfinConnectionParametersViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Jellyfin
-{
-    public record JellyfinConnectionParametersViewModel(string Address);
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record JellyfinConnectionParametersViewModel(string Address);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/JellyfinLibraryViewModel.cs b/ErsatzTV.Application/Jellyfin/JellyfinLibraryViewModel.cs
index 2cc95f476..24e661db4 100644
--- a/ErsatzTV.Application/Jellyfin/JellyfinLibraryViewModel.cs
+++ b/ErsatzTV.Application/Jellyfin/JellyfinLibraryViewModel.cs
@@ -1,8 +1,7 @@
 using ErsatzTV.Application.Libraries;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Jellyfin
-{
-    public record JellyfinLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems)
-        : LibraryViewModel("Jellyfin", Id, Name, MediaKind);
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record JellyfinLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems)
+    : LibraryViewModel("Jellyfin", Id, Name, MediaKind);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/JellyfinMediaSourceViewModel.cs b/ErsatzTV.Application/Jellyfin/JellyfinMediaSourceViewModel.cs
index 361a6b948..b5db08944 100644
--- a/ErsatzTV.Application/Jellyfin/JellyfinMediaSourceViewModel.cs
+++ b/ErsatzTV.Application/Jellyfin/JellyfinMediaSourceViewModel.cs
@@ -1,9 +1,8 @@
 using ErsatzTV.Application.MediaSources;
 
-namespace ErsatzTV.Application.Jellyfin
-{
-    public record JellyfinMediaSourceViewModel(int Id, string Name, string Address) : RemoteMediaSourceViewModel(
-        Id,
-        Name,
-        Address);
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record JellyfinMediaSourceViewModel(int Id, string Name, string Address) : RemoteMediaSourceViewModel(
+    Id,
+    Name,
+    Address);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/JellyfinPathReplacementViewModel.cs b/ErsatzTV.Application/Jellyfin/JellyfinPathReplacementViewModel.cs
index 624e9ae13..fa80a7297 100644
--- a/ErsatzTV.Application/Jellyfin/JellyfinPathReplacementViewModel.cs
+++ b/ErsatzTV.Application/Jellyfin/JellyfinPathReplacementViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Jellyfin
-{
-    public record JellyfinPathReplacementViewModel(int Id, string JellyfinPath, string LocalPath);
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record JellyfinPathReplacementViewModel(int Id, string JellyfinPath, string LocalPath);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Mapper.cs b/ErsatzTV.Application/Jellyfin/Mapper.cs
index eab0ebbb8..f696ff259 100644
--- a/ErsatzTV.Application/Jellyfin/Mapper.cs
+++ b/ErsatzTV.Application/Jellyfin/Mapper.cs
@@ -1,19 +1,18 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Jellyfin
+namespace ErsatzTV.Application.Jellyfin;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static JellyfinMediaSourceViewModel ProjectToViewModel(JellyfinMediaSource jellyfinMediaSource) =>
-            new(
-                jellyfinMediaSource.Id,
-                jellyfinMediaSource.ServerName,
-                jellyfinMediaSource.Connections.HeadOrNone().Match(c => c.Address, string.Empty));
+    internal static JellyfinMediaSourceViewModel ProjectToViewModel(JellyfinMediaSource jellyfinMediaSource) =>
+        new(
+            jellyfinMediaSource.Id,
+            jellyfinMediaSource.ServerName,
+            jellyfinMediaSource.Connections.HeadOrNone().Match(c => c.Address, string.Empty));
 
-        internal static JellyfinLibraryViewModel ProjectToViewModel(JellyfinLibrary library) =>
-            new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
+    internal static JellyfinLibraryViewModel ProjectToViewModel(JellyfinLibrary library) =>
+        new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
 
-        internal static JellyfinPathReplacementViewModel ProjectToViewModel(JellyfinPathReplacement pathReplacement) =>
-            new(pathReplacement.Id, pathReplacement.JellyfinPath, pathReplacement.LocalPath);
-    }
-}
+    internal static JellyfinPathReplacementViewModel ProjectToViewModel(JellyfinPathReplacement pathReplacement) =>
+        new(pathReplacement.Id, pathReplacement.JellyfinPath, pathReplacement.LocalPath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSources.cs b/ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSources.cs
index c02e83261..032f4c828 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSources.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSources.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Jellyfin;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
-{
-    public record GetAllJellyfinMediaSources : IRequest<List<JellyfinMediaSourceViewModel>>;
-}
+public record GetAllJellyfinMediaSources : IRequest<List<JellyfinMediaSourceViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSourcesHandler.cs b/ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSourcesHandler.cs
index 948f66a6f..330797299 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSourcesHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetAllJellyfinMediaSourcesHandler.cs
@@ -1,26 +1,19 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Jellyfin.Mapper;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
+namespace ErsatzTV.Application.Jellyfin;
+
+public class
+    GetAllJellyfinMediaSourcesHandler : IRequestHandler<GetAllJellyfinMediaSources,
+        List<JellyfinMediaSourceViewModel>>
 {
-    public class
-        GetAllJellyfinMediaSourcesHandler : IRequestHandler<GetAllJellyfinMediaSources,
-            List<JellyfinMediaSourceViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetAllJellyfinMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetAllJellyfinMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<JellyfinMediaSourceViewModel>> Handle(
-            GetAllJellyfinMediaSources request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetAllJellyfin().Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<JellyfinMediaSourceViewModel>> Handle(
+        GetAllJellyfinMediaSources request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetAllJellyfin().Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParameters.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParameters.cs
index b3666e6dc..f007ee670 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParameters.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParameters.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
-{
-    public record GetJellyfinConnectionParameters : IRequest<Either<BaseError, JellyfinConnectionParametersViewModel>>;
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record GetJellyfinConnectionParameters : IRequest<Either<BaseError, JellyfinConnectionParametersViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParametersHandler.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParametersHandler.cs
index 23f359575..07fdfc781 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParametersHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinConnectionParametersHandler.cs
@@ -1,73 +1,66 @@
-using System;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.Caching.Memory;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
+namespace ErsatzTV.Application.Jellyfin;
+
+public class GetJellyfinConnectionParametersHandler : IRequestHandler<GetJellyfinConnectionParameters,
+    Either<BaseError, JellyfinConnectionParametersViewModel>>
 {
-    public class GetJellyfinConnectionParametersHandler : IRequestHandler<GetJellyfinConnectionParameters,
-        Either<BaseError, JellyfinConnectionParametersViewModel>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMemoryCache _memoryCache;
+
+    public GetJellyfinConnectionParametersHandler(
+        IMemoryCache memoryCache,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMemoryCache _memoryCache;
-
-        public GetJellyfinConnectionParametersHandler(
-            IMemoryCache memoryCache,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _memoryCache = memoryCache;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<Either<BaseError, JellyfinConnectionParametersViewModel>> Handle(
-            GetJellyfinConnectionParameters request,
-            CancellationToken cancellationToken)
-        {
-            if (_memoryCache.TryGetValue(request, out JellyfinConnectionParametersViewModel parameters))
-            {
-                return parameters;
-            }
-
-            Either<BaseError, JellyfinConnectionParametersViewModel> maybeParameters =
-                await Validate()
-                    .MapT(cp => new JellyfinConnectionParametersViewModel(cp.ActiveConnection.Address))
-                    .Map(v => v.ToEither<JellyfinConnectionParametersViewModel>());
-
-            return maybeParameters.Match(
-                p =>
-                {
-                    _memoryCache.Set(request, p, TimeSpan.FromHours(1));
-                    return maybeParameters;
-                },
-                error => error);
-        }
-
-        private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
-            JellyfinMediaSourceMustExist()
-                .BindT(MediaSourceMustHaveActiveConnection);
-
-        private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist() =>
-            _mediaSourceRepository.GetAllJellyfin().Map(list => list.HeadOrNone())
-                .Map(
-                    v => v.ToValidation<BaseError>(
-                        "Jellyfin media source does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            JellyfinMediaSource jellyfinMediaSource)
-        {
-            Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.FirstOrDefault();
-            return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
-                .ToValidation<BaseError>("Jellyfin media source requires an active connection");
-        }
-
-        private record ConnectionParameters(
-            JellyfinMediaSource JellyfinMediaSource,
-            JellyfinConnection ActiveConnection);
+        _memoryCache = memoryCache;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<Either<BaseError, JellyfinConnectionParametersViewModel>> Handle(
+        GetJellyfinConnectionParameters request,
+        CancellationToken cancellationToken)
+    {
+        if (_memoryCache.TryGetValue(request, out JellyfinConnectionParametersViewModel parameters))
+        {
+            return parameters;
+        }
+
+        Either<BaseError, JellyfinConnectionParametersViewModel> maybeParameters =
+            await Validate()
+                .MapT(cp => new JellyfinConnectionParametersViewModel(cp.ActiveConnection.Address))
+                .Map(v => v.ToEither<JellyfinConnectionParametersViewModel>());
+
+        return maybeParameters.Match(
+            p =>
+            {
+                _memoryCache.Set(request, p, TimeSpan.FromHours(1));
+                return maybeParameters;
+            },
+            error => error);
+    }
+
+    private Task<Validation<BaseError, ConnectionParameters>> Validate() =>
+        JellyfinMediaSourceMustExist()
+            .BindT(MediaSourceMustHaveActiveConnection);
+
+    private Task<Validation<BaseError, JellyfinMediaSource>> JellyfinMediaSourceMustExist() =>
+        _mediaSourceRepository.GetAllJellyfin().Map(list => list.HeadOrNone())
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    "Jellyfin media source does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        JellyfinMediaSource jellyfinMediaSource)
+    {
+        Option<JellyfinConnection> maybeConnection = jellyfinMediaSource.Connections.FirstOrDefault();
+        return maybeConnection.Map(connection => new ConnectionParameters(jellyfinMediaSource, connection))
+            .ToValidation<BaseError>("Jellyfin media source requires an active connection");
+    }
+
+    private record ConnectionParameters(
+        JellyfinMediaSource JellyfinMediaSource,
+        JellyfinConnection ActiveConnection);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceId.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceId.cs
index 2d5e106ec..7e9783c49 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceId.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceId.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Jellyfin;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
-{
-    public record GetJellyfinLibrariesBySourceId(int JellyfinMediaSourceId) : IRequest<List<JellyfinLibraryViewModel>>;
-}
+public record GetJellyfinLibrariesBySourceId(int JellyfinMediaSourceId) : IRequest<List<JellyfinLibraryViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceIdHandler.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceIdHandler.cs
index a82c31e99..b1232a4bd 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceIdHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinLibrariesBySourceIdHandler.cs
@@ -1,27 +1,20 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Jellyfin.Mapper;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
+namespace ErsatzTV.Application.Jellyfin;
+
+public class
+    GetJellyfinLibrariesBySourceIdHandler : IRequestHandler<GetJellyfinLibrariesBySourceId,
+        List<JellyfinLibraryViewModel>>
 {
-    public class
-        GetJellyfinLibrariesBySourceIdHandler : IRequestHandler<GetJellyfinLibrariesBySourceId,
-            List<JellyfinLibraryViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetJellyfinLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetJellyfinLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<JellyfinLibraryViewModel>> Handle(
-            GetJellyfinLibrariesBySourceId request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetJellyfinLibraries(request.JellyfinMediaSourceId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<JellyfinLibraryViewModel>> Handle(
+        GetJellyfinLibrariesBySourceId request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetJellyfinLibraries(request.JellyfinMediaSourceId)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceById.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceById.cs
index 1ba7b8a09..b6808d9ae 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceById.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceById.cs
@@ -1,8 +1,4 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Jellyfin;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
-{
-    public record GetJellyfinMediaSourceById
-        (int JellyfinMediaSourceId) : IRequest<Option<JellyfinMediaSourceViewModel>>;
-}
+public record GetJellyfinMediaSourceById
+    (int JellyfinMediaSourceId) : IRequest<Option<JellyfinMediaSourceViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceByIdHandler.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceByIdHandler.cs
index a9cc36fab..9c9f7e454 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceByIdHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinMediaSourceByIdHandler.cs
@@ -1,24 +1,19 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Jellyfin.Mapper;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
+namespace ErsatzTV.Application.Jellyfin;
+
+public class
+    GetJellyfinMediaSourceByIdHandler : IRequestHandler<GetJellyfinMediaSourceById,
+        Option<JellyfinMediaSourceViewModel>>
 {
-    public class
-        GetJellyfinMediaSourceByIdHandler : IRequestHandler<GetJellyfinMediaSourceById,
-            Option<JellyfinMediaSourceViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetJellyfinMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetJellyfinMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<Option<JellyfinMediaSourceViewModel>> Handle(
-            GetJellyfinMediaSourceById request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId).MapT(ProjectToViewModel);
-    }
-}
+    public Task<Option<JellyfinMediaSourceViewModel>> Handle(
+        GetJellyfinMediaSourceById request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetJellyfin(request.JellyfinMediaSourceId).MapT(ProjectToViewModel);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceId.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceId.cs
index 73aa27862..83eadc9e6 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceId.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceId.cs
@@ -1,8 +1,4 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Jellyfin;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
-{
-    public record GetJellyfinPathReplacementsBySourceId
-        (int JellyfinMediaSourceId) : IRequest<List<JellyfinPathReplacementViewModel>>;
-}
+public record GetJellyfinPathReplacementsBySourceId
+    (int JellyfinMediaSourceId) : IRequest<List<JellyfinPathReplacementViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceIdHandler.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceIdHandler.cs
index 4db4d0226..b84654063 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceIdHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinPathReplacementsBySourceIdHandler.cs
@@ -1,26 +1,19 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Jellyfin.Mapper;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
+namespace ErsatzTV.Application.Jellyfin;
+
+public class GetJellyfinPathReplacementsBySourceIdHandler : IRequestHandler<GetJellyfinPathReplacementsBySourceId,
+    List<JellyfinPathReplacementViewModel>>
 {
-    public class GetJellyfinPathReplacementsBySourceIdHandler : IRequestHandler<GetJellyfinPathReplacementsBySourceId,
-        List<JellyfinPathReplacementViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetJellyfinPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetJellyfinPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<JellyfinPathReplacementViewModel>> Handle(
-            GetJellyfinPathReplacementsBySourceId request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetJellyfinPathReplacements(request.JellyfinMediaSourceId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<JellyfinPathReplacementViewModel>> Handle(
+        GetJellyfinPathReplacementsBySourceId request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetJellyfinPathReplacements(request.JellyfinMediaSourceId)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecrets.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecrets.cs
index f0a8ef8cc..b67748306 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecrets.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecrets.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core.Jellyfin;
-using MediatR;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
-{
-    public record GetJellyfinSecrets : IRequest<JellyfinSecrets>;
-}
+namespace ErsatzTV.Application.Jellyfin;
+
+public record GetJellyfinSecrets : IRequest<JellyfinSecrets>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecretsHandler.cs b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecretsHandler.cs
index 135822f8f..3f93735b7 100644
--- a/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecretsHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Queries/GetJellyfinSecretsHandler.cs
@@ -1,19 +1,15 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Jellyfin;
+using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Jellyfin;
-using MediatR;
 
-namespace ErsatzTV.Application.Jellyfin.Queries
+namespace ErsatzTV.Application.Jellyfin;
+
+public class GetJellyfinSecretsHandler : IRequestHandler<GetJellyfinSecrets, JellyfinSecrets>
 {
-    public class GetJellyfinSecretsHandler : IRequestHandler<GetJellyfinSecrets, JellyfinSecrets>
-    {
-        private readonly IJellyfinSecretStore _jellyfinSecretStore;
+    private readonly IJellyfinSecretStore _jellyfinSecretStore;
 
-        public GetJellyfinSecretsHandler(IJellyfinSecretStore jellyfinSecretStore) =>
-            _jellyfinSecretStore = jellyfinSecretStore;
+    public GetJellyfinSecretsHandler(IJellyfinSecretStore jellyfinSecretStore) =>
+        _jellyfinSecretStore = jellyfinSecretStore;
 
-        public Task<JellyfinSecrets> Handle(GetJellyfinSecrets request, CancellationToken cancellationToken) =>
-            _jellyfinSecretStore.ReadSecrets();
-    }
-}
+    public Task<JellyfinSecrets> Handle(GetJellyfinSecrets request, CancellationToken cancellationToken) =>
+        _jellyfinSecretStore.ReadSecrets();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibrary.cs b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibrary.cs
index 01f856685..b31e02118 100644
--- a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibrary.cs
+++ b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibrary.cs
@@ -1,11 +1,7 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Libraries.Commands
-{
-    public record CreateLocalLibrary(string Name, LibraryMediaKind MediaKind, List<string> Paths)
-        : ILocalLibraryRequest, IRequest<Either<BaseError, LocalLibraryViewModel>>;
-}
+namespace ErsatzTV.Application.Libraries;
+
+public record CreateLocalLibrary(string Name, LibraryMediaKind MediaKind, List<string> Paths)
+    : ILocalLibraryRequest, IRequest<Either<BaseError, LocalLibraryViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs
index dc5a7e8bf..83ed4eac8 100644
--- a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs
@@ -1,83 +1,76 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaSources.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.MediaSources;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Libraries.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Libraries.Commands
+namespace ErsatzTV.Application.Libraries;
+
+public class CreateLocalLibraryHandler : LocalLibraryHandlerBase,
+    IRequestHandler<CreateLocalLibrary, Either<BaseError, LocalLibraryViewModel>>
 {
-    public class CreateLocalLibraryHandler : LocalLibraryHandlerBase,
-        IRequestHandler<CreateLocalLibrary, Either<BaseError, LocalLibraryViewModel>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+    private readonly IEntityLocker _entityLocker;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateLocalLibraryHandler(
+        ChannelWriter<IBackgroundServiceRequest> workerChannel,
+        IEntityLocker entityLocker,
+        IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
-        private readonly IEntityLocker _entityLocker;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreateLocalLibraryHandler(
-            ChannelWriter<IBackgroundServiceRequest> workerChannel,
-            IEntityLocker entityLocker,
-            IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _workerChannel = workerChannel;
-            _entityLocker = entityLocker;
-            _dbContextFactory = dbContextFactory;
-        }
-
-        public async Task<Either<BaseError, LocalLibraryViewModel>> Handle(
-            CreateLocalLibrary request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            Validation<BaseError, LocalLibrary> validation = await Validate(dbContext, request);
-            return await validation.Apply(localLibrary => PersistLocalLibrary(dbContext, localLibrary));
-        }
-
-        private async Task<LocalLibraryViewModel> PersistLocalLibrary(
-            TvContext dbContext,
-            LocalLibrary localLibrary)
-        {
-            await dbContext.LocalLibraries.AddAsync(localLibrary);
-            await dbContext.SaveChangesAsync();
-            
-            if (_entityLocker.LockLibrary(localLibrary.Id))
-            {
-                await _workerChannel.WriteAsync(new ForceScanLocalLibrary(localLibrary.Id));
-            }
-
-            return ProjectToViewModel(localLibrary);
-        }
-
-        private static Task<Validation<BaseError, LocalLibrary>> Validate(
-            TvContext dbContext,
-            CreateLocalLibrary request) =>
-            MediaSourceMustExist(dbContext, request)
-                .BindT(localLibrary => NameMustBeValid(request, localLibrary))
-                .BindT(localLibrary => PathsMustBeValid(dbContext, localLibrary));
-
-        private static Task<Validation<BaseError, LocalLibrary>> MediaSourceMustExist(
-            TvContext dbContext,
-            CreateLocalLibrary request) =>
-            dbContext.LocalMediaSources
-                .OrderBy(lms => lms.Id)
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(
-                    lms => new LocalLibrary
-                    {
-                        Name = request.Name,
-                        Paths = request.Paths.Map(p => new LibraryPath { Path = p }).ToList(),
-                        MediaKind = request.MediaKind,
-                        MediaSourceId = lms.Id
-                    })
-                .Map(o => o.ToValidation<BaseError>("LocalMediaSource does not exist."));
+        _workerChannel = workerChannel;
+        _entityLocker = entityLocker;
+        _dbContextFactory = dbContextFactory;
     }
-}
+
+    public async Task<Either<BaseError, LocalLibraryViewModel>> Handle(
+        CreateLocalLibrary request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, LocalLibrary> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, localLibrary => PersistLocalLibrary(dbContext, localLibrary));
+    }
+
+    private async Task<LocalLibraryViewModel> PersistLocalLibrary(
+        TvContext dbContext,
+        LocalLibrary localLibrary)
+    {
+        await dbContext.LocalLibraries.AddAsync(localLibrary);
+        await dbContext.SaveChangesAsync();
+            
+        if (_entityLocker.LockLibrary(localLibrary.Id))
+        {
+            await _workerChannel.WriteAsync(new ForceScanLocalLibrary(localLibrary.Id));
+        }
+
+        return ProjectToViewModel(localLibrary);
+    }
+
+    private static Task<Validation<BaseError, LocalLibrary>> Validate(
+        TvContext dbContext,
+        CreateLocalLibrary request) =>
+        MediaSourceMustExist(dbContext, request)
+            .BindT(localLibrary => NameMustBeValid(request, localLibrary))
+            .BindT(localLibrary => PathsMustBeValid(dbContext, localLibrary));
+
+    private static Task<Validation<BaseError, LocalLibrary>> MediaSourceMustExist(
+        TvContext dbContext,
+        CreateLocalLibrary request) =>
+        dbContext.LocalMediaSources
+            .OrderBy(lms => lms.Id)
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(
+                lms => new LocalLibrary
+                {
+                    Name = request.Name,
+                    Paths = request.Paths.Map(p => new LibraryPath { Path = p }).ToList(),
+                    MediaKind = request.MediaKind,
+                    MediaSourceId = lms.Id
+                })
+            .Map(o => o.ToValidation<BaseError>("LocalMediaSource does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPath.cs b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPath.cs
index 8970f67b9..d53b74971 100644
--- a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPath.cs
+++ b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPath.cs
@@ -1,9 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Libraries.Commands
-{
-    public record CreateLocalLibraryPath
-        (int LibraryId, string Path) : IRequest<Either<BaseError, LocalLibraryPathViewModel>>;
-}
+namespace ErsatzTV.Application.Libraries;
+
+public record CreateLocalLibraryPath
+    (int LibraryId, string Path) : IRequest<Either<BaseError, LocalLibraryPathViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs
index 2cd3903dd..72470d58e 100644
--- a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs
@@ -1,61 +1,51 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
-using static LanguageExt.Prelude;
 using static ErsatzTV.Application.Libraries.Mapper;
 
-namespace ErsatzTV.Application.Libraries.Commands
+namespace ErsatzTV.Application.Libraries;
+
+public class CreateLocalLibraryPathHandler : IRequestHandler<CreateLocalLibraryPath,
+    Either<BaseError, LocalLibraryPathViewModel>>
 {
-    public class CreateLocalLibraryPathHandler : IRequestHandler<CreateLocalLibraryPath,
-        Either<BaseError, LocalLibraryPathViewModel>>
+    private readonly ILibraryRepository _libraryRepository;
+
+    public CreateLocalLibraryPathHandler(ILibraryRepository libraryRepository) =>
+        _libraryRepository = libraryRepository;
+
+    public Task<Either<BaseError, LocalLibraryPathViewModel>> Handle(
+        CreateLocalLibraryPath request,
+        CancellationToken cancellationToken) =>
+        Validate(request).MapT(PersistLocalLibraryPath).Bind(v => v.ToEitherAsync());
+
+    private Task<LocalLibraryPathViewModel> PersistLocalLibraryPath(LibraryPath p) =>
+        _libraryRepository.Add(p).Map(ProjectToViewModel);
+
+    private Task<Validation<BaseError, LibraryPath>> Validate(CreateLocalLibraryPath request) =>
+        ValidateFolder(request)
+            .MapT(
+                folder =>
+                    new LibraryPath
+                    {
+                        LibraryId = request.LibraryId,
+                        Path = folder
+                    });
+
+    private async Task<Validation<BaseError, string>> ValidateFolder(CreateLocalLibraryPath request)
     {
-        private readonly ILibraryRepository _libraryRepository;
+        List<string> allPaths = await _libraryRepository.GetLocalPaths(request.LibraryId)
+            .Map(list => list.Map(c => c.Path).ToList());
 
-        public CreateLocalLibraryPathHandler(ILibraryRepository libraryRepository) =>
-            _libraryRepository = libraryRepository;
-
-        public Task<Either<BaseError, LocalLibraryPathViewModel>> Handle(
-            CreateLocalLibraryPath request,
-            CancellationToken cancellationToken) =>
-            Validate(request).MapT(PersistLocalLibraryPath).Bind(v => v.ToEitherAsync());
-
-        private Task<LocalLibraryPathViewModel> PersistLocalLibraryPath(LibraryPath p) =>
-            _libraryRepository.Add(p).Map(ProjectToViewModel);
-
-        private Task<Validation<BaseError, LibraryPath>> Validate(CreateLocalLibraryPath request) =>
-            ValidateFolder(request)
-                .MapT(
-                    folder =>
-                        new LibraryPath
-                        {
-                            LibraryId = request.LibraryId,
-                            Path = folder
-                        });
-
-        private async Task<Validation<BaseError, string>> ValidateFolder(CreateLocalLibraryPath request)
-        {
-            List<string> allPaths = await _libraryRepository.GetLocalPaths(request.LibraryId)
-                .Map(list => list.Map(c => c.Path).ToList());
-
-            return Optional(request.Path)
-                .Where(folder => allPaths.ForAll(f => !AreSubPaths(f, folder)))
-                .ToValidation<BaseError>("Path must not belong to another library path");
-        }
-
-        private static bool AreSubPaths(string path1, string path2)
-        {
-            string one = path1 + Path.DirectorySeparatorChar;
-            string two = path2 + Path.DirectorySeparatorChar;
-            return one == two || one.StartsWith(two, StringComparison.OrdinalIgnoreCase) ||
-                   two.StartsWith(one, StringComparison.OrdinalIgnoreCase);
-        }
+        return Optional(request.Path)
+            .Where(folder => allPaths.ForAll(f => !AreSubPaths(f, folder)))
+            .ToValidation<BaseError>("Path must not belong to another library path");
     }
-}
+
+    private static bool AreSubPaths(string path1, string path2)
+    {
+        string one = path1 + Path.DirectorySeparatorChar;
+        string two = path2 + Path.DirectorySeparatorChar;
+        return one == two || one.StartsWith(two, StringComparison.OrdinalIgnoreCase) ||
+               two.StartsWith(one, StringComparison.OrdinalIgnoreCase);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/DeleteLocalLibrary.cs b/ErsatzTV.Application/Libraries/Commands/DeleteLocalLibrary.cs
index 6a425d305..e563241c2 100644
--- a/ErsatzTV.Application/Libraries/Commands/DeleteLocalLibrary.cs
+++ b/ErsatzTV.Application/Libraries/Commands/DeleteLocalLibrary.cs
@@ -1,9 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Libraries.Commands
-{
-    public record DeleteLocalLibrary(int LocalLibraryId) : IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Libraries;
+
+public record DeleteLocalLibrary(int LocalLibraryId) : IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryHandler.cs b/ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryHandler.cs
index 69fe3c933..d9ff2ca5e 100644
--- a/ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryHandler.cs
@@ -1,70 +1,62 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Libraries.Commands
+namespace ErsatzTV.Application.Libraries;
+
+public class DeleteLocalLibraryHandler : LocalLibraryHandlerBase,
+    IRequestHandler<DeleteLocalLibrary, Either<BaseError, Unit>>
 {
-    public class DeleteLocalLibraryHandler : LocalLibraryHandlerBase,
-        IRequestHandler<DeleteLocalLibrary, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IDbConnection _dbConnection;
+    private readonly ISearchIndex _searchIndex;
+
+    public DeleteLocalLibraryHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IDbConnection dbConnection,
+        ISearchIndex searchIndex)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IDbConnection _dbConnection;
-        private readonly ISearchIndex _searchIndex;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+        _searchIndex = searchIndex;
+    }
 
-        public DeleteLocalLibraryHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IDbConnection dbConnection,
-            ISearchIndex searchIndex)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-            _searchIndex = searchIndex;
-        }
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteLocalLibrary request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, LocalLibrary> validation =  await LocalLibraryMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, localLibrary => DoDeletion(dbContext, localLibrary));
+    }
 
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteLocalLibrary request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, LocalLibrary> validation =  await LocalLibraryMustExist(dbContext, request);
-            return await validation.Apply(localLibrary => DoDeletion(dbContext, localLibrary));
-        }
-
-        private async Task<Unit> DoDeletion(TvContext dbContext, LocalLibrary localLibrary)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                    @"SELECT MediaItem.Id FROM MediaItem
+    private async Task<Unit> DoDeletion(TvContext dbContext, LocalLibrary localLibrary)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+                @"SELECT MediaItem.Id FROM MediaItem
                       INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
                       WHERE LP.LibraryId = @LibraryId",
-                    new { LibraryId = localLibrary.Id })
-                .Map(result => result.ToList());
+                new { LibraryId = localLibrary.Id })
+            .Map(result => result.ToList());
 
-            await _searchIndex.RemoveItems(ids);
-            _searchIndex.Commit();
+        await _searchIndex.RemoveItems(ids);
+        _searchIndex.Commit();
 
-            dbContext.LocalLibraries.Remove(localLibrary);
-            await dbContext.SaveChangesAsync();
+        dbContext.LocalLibraries.Remove(localLibrary);
+        await dbContext.SaveChangesAsync();
 
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
-            TvContext dbContext,
-            DeleteLocalLibrary request) =>
-            dbContext.LocalLibraries
-                .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.LocalLibraryId)
-                .Map(o => o.ToValidation<BaseError>($"Local library {request.LocalLibraryId} does not exist."));
+        return Unit.Default;
     }
-}
+
+    private static Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
+        TvContext dbContext,
+        DeleteLocalLibrary request) =>
+        dbContext.LocalLibraries
+            .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.LocalLibraryId)
+            .Map(o => o.ToValidation<BaseError>($"Local library {request.LocalLibraryId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/ILocalLibraryRequest.cs b/ErsatzTV.Application/Libraries/Commands/ILocalLibraryRequest.cs
index 59682c5c0..0eba13106 100644
--- a/ErsatzTV.Application/Libraries/Commands/ILocalLibraryRequest.cs
+++ b/ErsatzTV.Application/Libraries/Commands/ILocalLibraryRequest.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Application.Libraries.Commands
+namespace ErsatzTV.Application.Libraries;
+
+public interface ILocalLibraryRequest
 {
-    public interface ILocalLibraryRequest
-    {
-        public string Name { get; }
-    }
-}
+    public string Name { get; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/LocalLibraryHandlerBase.cs b/ErsatzTV.Application/Libraries/Commands/LocalLibraryHandlerBase.cs
index 82d22acec..17688ce65 100644
--- a/ErsatzTV.Application/Libraries/Commands/LocalLibraryHandlerBase.cs
+++ b/ErsatzTV.Application/Libraries/Commands/LocalLibraryHandlerBase.cs
@@ -1,49 +1,41 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Libraries.Commands
+namespace ErsatzTV.Application.Libraries;
+
+public abstract class LocalLibraryHandlerBase
 {
-    public abstract class LocalLibraryHandlerBase
+    protected static Task<Validation<BaseError, LocalLibrary>> NameMustBeValid(
+        ILocalLibraryRequest request,
+        LocalLibrary localLibrary) =>
+        request.NotEmpty(c => c.Name)
+            .Bind(_ => request.NotLongerThan(50)(c => c.Name))
+            .Map(_ => localLibrary).AsTask();
+
+    protected static async Task<Validation<BaseError, LocalLibrary>> PathsMustBeValid(
+        TvContext dbContext,
+        LocalLibrary localLibrary,
+        int? existingLibraryId = null)
     {
-        protected static Task<Validation<BaseError, LocalLibrary>> NameMustBeValid(
-            ILocalLibraryRequest request,
-            LocalLibrary localLibrary) =>
-            request.NotEmpty(c => c.Name)
-                .Bind(_ => request.NotLongerThan(50)(c => c.Name))
-                .Map(_ => localLibrary).AsTask();
+        List<string> allPaths = await dbContext.LocalLibraries
+            .Include(ll => ll.Paths)
+            .Filter(ll => existingLibraryId == null || ll.Id != existingLibraryId)
+            .ToListAsync()
+            .Map(list => list.SelectMany(ll => ll.Paths).Map(lp => lp.Path).ToList());
 
-        protected static async Task<Validation<BaseError, LocalLibrary>> PathsMustBeValid(
-            TvContext dbContext,
-            LocalLibrary localLibrary,
-            int? existingLibraryId = null)
-        {
-            List<string> allPaths = await dbContext.LocalLibraries
-                .Include(ll => ll.Paths)
-                .Filter(ll => existingLibraryId == null || ll.Id != existingLibraryId)
-                .ToListAsync()
-                .Map(list => list.SelectMany(ll => ll.Paths).Map(lp => lp.Path).ToList());
-
-            return Optional(localLibrary.Paths.Count(folder => allPaths.Any(f => AreSubPaths(f, folder.Path))))
-                .Where(length => length == 0)
-                .Map(_ => localLibrary)
-                .ToValidation<BaseError>("Path must not belong to another library path");
-        }
-        
-        private static bool AreSubPaths(string path1, string path2)
-        {
-            string one = path1 + Path.DirectorySeparatorChar;
-            string two = path2 + Path.DirectorySeparatorChar;
-            return one == two || one.StartsWith(two, StringComparison.OrdinalIgnoreCase) ||
-                   two.StartsWith(one, StringComparison.OrdinalIgnoreCase);
-        }
+        return Optional(localLibrary.Paths.Count(folder => allPaths.Any(f => AreSubPaths(f, folder.Path))))
+            .Where(length => length == 0)
+            .Map(_ => localLibrary)
+            .ToValidation<BaseError>("Path must not belong to another library path");
     }
-}
+        
+    private static bool AreSubPaths(string path1, string path2)
+    {
+        string one = path1 + Path.DirectorySeparatorChar;
+        string two = path2 + Path.DirectorySeparatorChar;
+        return one == two || one.StartsWith(two, StringComparison.OrdinalIgnoreCase) ||
+               two.StartsWith(one, StringComparison.OrdinalIgnoreCase);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPath.cs b/ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPath.cs
index 588008308..ecf9d52b9 100644
--- a/ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPath.cs
+++ b/ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPath.cs
@@ -1,9 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Libraries.Commands
-{
-    public record MoveLocalLibraryPath(int LibraryPathId, int TargetLibraryId) : IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Libraries;
+
+public record MoveLocalLibraryPath(int LibraryPathId, int TargetLibraryId) : IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPathHandler.cs b/ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPathHandler.cs
index ab98e318c..91e8980e4 100644
--- a/ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPathHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPathHandler.cs
@@ -1,8 +1,4 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -10,112 +6,108 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Libraries.Commands
+namespace ErsatzTV.Application.Libraries;
+
+public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath, Either<BaseError, Unit>>
 {
-    public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath, Either<BaseError, Unit>>
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IDbConnection _dbConnection;
+    private readonly ILogger<MoveLocalLibraryPathHandler> _logger;
+
+    public MoveLocalLibraryPathHandler(
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        IDbContextFactory<TvContext> dbContextFactory,
+        IDbConnection dbConnection,
+        ILogger<MoveLocalLibraryPathHandler> logger)
     {
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IDbConnection _dbConnection;
-        private readonly ILogger<MoveLocalLibraryPathHandler> _logger;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+        _logger = logger;
+    }
 
-        public MoveLocalLibraryPathHandler(
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            IDbContextFactory<TvContext> dbContextFactory,
-            IDbConnection dbConnection,
-            ILogger<MoveLocalLibraryPathHandler> logger)
+    public async Task<Either<BaseError, Unit>> Handle(
+        MoveLocalLibraryPath request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => MovePath(dbContext, parameters));
+    }
+
+    private async Task<Unit> MovePath(TvContext dbContext, Parameters parameters)
+    {
+        LibraryPath path = parameters.LibraryPath;
+        LocalLibrary newLibrary = parameters.Library;
+
+        path.LibraryId = newLibrary.Id;
+        if (await dbContext.SaveChangesAsync() > 0)
         {
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-            _logger = logger;
-        }
+            List<int> ids = await _dbConnection.QueryAsync<int>(
+                    @"SELECT MediaItem.Id FROM MediaItem WHERE LibraryPathId = @LibraryPathId",
+                    new { LibraryPathId = path.Id })
+                .Map(result => result.ToList());
 
-        public async Task<Either<BaseError, Unit>> Handle(
-            MoveLocalLibraryPath request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => MovePath(dbContext, parameters));
-        }
-
-        private async Task<Unit> MovePath(TvContext dbContext, Parameters parameters)
-        {
-            LibraryPath path = parameters.LibraryPath;
-            LocalLibrary newLibrary = parameters.Library;
-
-            path.LibraryId = newLibrary.Id;
-            if (await dbContext.SaveChangesAsync() > 0)
+            foreach (int id in ids)
             {
-                List<int> ids = await _dbConnection.QueryAsync<int>(
-                        @"SELECT MediaItem.Id FROM MediaItem WHERE LibraryPathId = @LibraryPathId",
-                        new { LibraryPathId = path.Id })
-                    .Map(result => result.ToList());
-
-                foreach (int id in ids)
+                Option<MediaItem> maybeMediaItem = await _searchRepository.GetItemToIndex(id);
+                foreach (MediaItem mediaItem in maybeMediaItem)
                 {
-                    Option<MediaItem> maybeMediaItem = await _searchRepository.GetItemToIndex(id);
-                    foreach (MediaItem mediaItem in maybeMediaItem)
-                    {
-                        _logger.LogInformation("Moving item at {Path}", await GetPath(mediaItem));
-                        await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { mediaItem });
-                    }
+                    _logger.LogInformation("Moving item at {Path}", await GetPath(mediaItem));
+                    await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { mediaItem });
                 }
             }
-
-            return Unit.Default;
         }
 
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            MoveLocalLibraryPath request) =>
-            (await LibraryPathMustExist(dbContext, request), await LocalLibraryMustExist(dbContext, request))
-            .Apply((libraryPath, localLibrary) => new Parameters(libraryPath, localLibrary));
+        return Unit.Default;
+    }
 
-        private static Task<Validation<BaseError, LibraryPath>> LibraryPathMustExist(
-            TvContext dbContext,
-            MoveLocalLibraryPath request) =>
-            dbContext.LibraryPaths
-                .Include(lp => lp.Library)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.LibraryPathId)
-                .Map(o => o.ToValidation<BaseError>("LibraryPath does not exist."));
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        MoveLocalLibraryPath request) =>
+        (await LibraryPathMustExist(dbContext, request), await LocalLibraryMustExist(dbContext, request))
+        .Apply((libraryPath, localLibrary) => new Parameters(libraryPath, localLibrary));
 
-        private static Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
-            TvContext dbContext,
-            MoveLocalLibraryPath request) =>
-            dbContext.LocalLibraries
-                .Include(ll => ll.Paths)
-                .SelectOneAsync(a => a.Id, a => a.Id == request.TargetLibraryId)
-                .Map(o => o.ToValidation<BaseError>("LocalLibrary does not exist"));
+    private static Task<Validation<BaseError, LibraryPath>> LibraryPathMustExist(
+        TvContext dbContext,
+        MoveLocalLibraryPath request) =>
+        dbContext.LibraryPaths
+            .Include(lp => lp.Library)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.LibraryPathId)
+            .Map(o => o.ToValidation<BaseError>("LibraryPath does not exist."));
 
-        private async Task<string> GetPath(MediaItem mediaItem) =>
-            mediaItem switch
-            {
-                Movie => await _dbConnection.QuerySingleAsync<string>(
-                    @"SELECT Path FROM MediaFile
+    private static Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
+        TvContext dbContext,
+        MoveLocalLibraryPath request) =>
+        dbContext.LocalLibraries
+            .Include(ll => ll.Paths)
+            .SelectOneAsync(a => a.Id, a => a.Id == request.TargetLibraryId)
+            .Map(o => o.ToValidation<BaseError>("LocalLibrary does not exist"));
+
+    private async Task<string> GetPath(MediaItem mediaItem) =>
+        mediaItem switch
+        {
+            Movie => await _dbConnection.QuerySingleAsync<string>(
+                @"SELECT Path FROM MediaFile
                       INNER JOIN MediaVersion MV on MediaFile.MediaVersionId = MV.Id
                       WHERE MV.MovieId = @Id", new { mediaItem.Id }),
-                Episode => await _dbConnection.QuerySingleAsync<string>(
-                    @"SELECT Path FROM MediaFile
+            Episode => await _dbConnection.QuerySingleAsync<string>(
+                @"SELECT Path FROM MediaFile
                       INNER JOIN MediaVersion MV on MediaFile.MediaVersionId = MV.Id
                       WHERE MV.EpisodeId = @Id", new { mediaItem.Id }),
-                MusicVideo => await _dbConnection.QuerySingleAsync<string>(
-                    @"SELECT Path FROM MediaFile
+            MusicVideo => await _dbConnection.QuerySingleAsync<string>(
+                @"SELECT Path FROM MediaFile
                       INNER JOIN MediaVersion MV on MediaFile.MediaVersionId = MV.Id
                       WHERE MV.MusicVideoId = @Id", new { mediaItem.Id }),
-                _ => null
-            };
+            _ => null
+        };
 
-        private record Parameters(LibraryPath LibraryPath, LocalLibrary Library);
-    }
-}
+    private record Parameters(LibraryPath LibraryPath, LocalLibrary Library);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibrary.cs b/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibrary.cs
index efc73b4d0..1116d7047 100644
--- a/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibrary.cs
+++ b/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibrary.cs
@@ -1,12 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Libraries.Commands
-{
-    public record UpdateLocalLibraryPath(int Id, string Path);
+namespace ErsatzTV.Application.Libraries;
 
-    public record UpdateLocalLibrary(int Id, string Name, List<UpdateLocalLibraryPath> Paths) : ILocalLibraryRequest,
-        IRequest<Either<BaseError, LocalLibraryViewModel>>;
-}
+public record UpdateLocalLibraryPath(int Id, string Path);
+
+public record UpdateLocalLibrary(int Id, string Name, List<UpdateLocalLibraryPath> Paths) : ILocalLibraryRequest,
+    IRequest<Either<BaseError, LocalLibraryViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs b/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs
index c4f4576f9..3aa29fbf1 100644
--- a/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs
@@ -1,125 +1,116 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaSources.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.MediaSources;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Libraries.Mapper;
 
-namespace ErsatzTV.Application.Libraries.Commands
+namespace ErsatzTV.Application.Libraries;
+
+public class UpdateLocalLibraryHandler : LocalLibraryHandlerBase,
+    IRequestHandler<UpdateLocalLibrary, Either<BaseError, LocalLibraryViewModel>>
 {
-    public class UpdateLocalLibraryHandler : LocalLibraryHandlerBase,
-        IRequestHandler<UpdateLocalLibrary, Either<BaseError, LocalLibraryViewModel>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+    private readonly IEntityLocker _entityLocker;
+    private readonly ISearchIndex _searchIndex;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdateLocalLibraryHandler(
+        ChannelWriter<IBackgroundServiceRequest> workerChannel,
+        IEntityLocker entityLocker,
+        ISearchIndex searchIndex,
+        IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
-        private readonly IEntityLocker _entityLocker;
-        private readonly ISearchIndex _searchIndex;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdateLocalLibraryHandler(
-            ChannelWriter<IBackgroundServiceRequest> workerChannel,
-            IEntityLocker entityLocker,
-            ISearchIndex searchIndex,
-            IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _workerChannel = workerChannel;
-            _entityLocker = entityLocker;
-            _searchIndex = searchIndex;
-            _dbContextFactory = dbContextFactory;
-        }
-
-        public async Task<Either<BaseError, LocalLibraryViewModel>> Handle(
-            UpdateLocalLibrary request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => UpdateLocalLibrary(dbContext, parameters));
-        }
-
-        private async Task<LocalLibraryViewModel> UpdateLocalLibrary(TvContext dbContext, Parameters parameters)
-        {
-            (LocalLibrary existing, LocalLibrary incoming) = parameters;
-            existing.Name = incoming.Name;
-            
-            var toAdd = incoming.Paths
-                .Filter(p => existing.Paths.All(ep => NormalizePath(ep.Path) != NormalizePath(p.Path)))
-                .ToList();
-            var toRemove = existing.Paths
-                .Filter(ep => incoming.Paths.All(p => NormalizePath(p.Path) != NormalizePath(ep.Path)))
-                .ToList();
-
-            var toRemoveIds = toRemove.Map(lp => lp.Id).ToList();
-
-            List<int> itemsToRemove = await dbContext.MediaItems
-                .Filter(mi => toRemoveIds.Contains(mi.LibraryPathId))
-                .Map(mi => mi.Id)
-                .ToListAsync();
-            
-            existing.Paths.RemoveAll(toRemove.Contains);
-            existing.Paths.AddRange(toAdd);
-
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                await _searchIndex.RemoveItems(itemsToRemove);
-                _searchIndex.Commit();
-            }
-
-            if ((toAdd.Count > 0 || toRemove.Count > 0) && _entityLocker.LockLibrary(existing.Id))
-            {
-                await _workerChannel.WriteAsync(new ForceScanLocalLibrary(existing.Id));
-            }
-
-            return ProjectToViewModel(existing);
-        }
-
-        private static Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            UpdateLocalLibrary request) =>
-            LocalLibraryMustExist(dbContext, request)
-                .BindT(parameters => NameMustBeValid(request, parameters.Incoming).MapT(_ => parameters))
-                .BindT(
-                    parameters => PathsMustBeValid(dbContext, parameters.Incoming, parameters.Existing.Id)
-                        .MapT(_ => parameters));
-
-        private static Task<Validation<BaseError, Parameters>> LocalLibraryMustExist(
-            TvContext dbContext,
-            UpdateLocalLibrary request) =>
-            dbContext.LocalLibraries
-                .Include(ll => ll.Paths)
-                .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.Id)
-                .MapT(
-                    existing =>
-                    {
-                        var incoming = new LocalLibrary
-                        {
-                            Name = request.Name,
-                            Paths = request.Paths.Map(p => new LibraryPath { Id = p.Id, Path = p.Path }).ToList(),
-                            MediaSourceId = existing.Id
-                        };
-
-                        return new Parameters(existing, incoming);
-                    })
-                .Map(o => o.ToValidation<BaseError>("LocalLibrary does not exist."));
-
-        private record Parameters(LocalLibrary Existing, LocalLibrary Incoming);
-        
-        private static string NormalizePath(string path)
-        {
-            return Path.GetFullPath(new Uri(path).LocalPath)
-                .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
-                .ToUpperInvariant();
-        }
+        _workerChannel = workerChannel;
+        _entityLocker = entityLocker;
+        _searchIndex = searchIndex;
+        _dbContextFactory = dbContextFactory;
     }
-}
+
+    public async Task<Either<BaseError, LocalLibraryViewModel>> Handle(
+        UpdateLocalLibrary request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => UpdateLocalLibrary(dbContext, parameters));
+    }
+
+    private async Task<LocalLibraryViewModel> UpdateLocalLibrary(TvContext dbContext, Parameters parameters)
+    {
+        (LocalLibrary existing, LocalLibrary incoming) = parameters;
+        existing.Name = incoming.Name;
+            
+        var toAdd = incoming.Paths
+            .Filter(p => existing.Paths.All(ep => NormalizePath(ep.Path) != NormalizePath(p.Path)))
+            .ToList();
+        var toRemove = existing.Paths
+            .Filter(ep => incoming.Paths.All(p => NormalizePath(p.Path) != NormalizePath(ep.Path)))
+            .ToList();
+
+        var toRemoveIds = toRemove.Map(lp => lp.Id).ToList();
+
+        List<int> itemsToRemove = await dbContext.MediaItems
+            .Filter(mi => toRemoveIds.Contains(mi.LibraryPathId))
+            .Map(mi => mi.Id)
+            .ToListAsync();
+            
+        existing.Paths.RemoveAll(toRemove.Contains);
+        existing.Paths.AddRange(toAdd);
+
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            await _searchIndex.RemoveItems(itemsToRemove);
+            _searchIndex.Commit();
+        }
+
+        if ((toAdd.Count > 0 || toRemove.Count > 0) && _entityLocker.LockLibrary(existing.Id))
+        {
+            await _workerChannel.WriteAsync(new ForceScanLocalLibrary(existing.Id));
+        }
+
+        return ProjectToViewModel(existing);
+    }
+
+    private static Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        UpdateLocalLibrary request) =>
+        LocalLibraryMustExist(dbContext, request)
+            .BindT(parameters => NameMustBeValid(request, parameters.Incoming).MapT(_ => parameters))
+            .BindT(
+                parameters => PathsMustBeValid(dbContext, parameters.Incoming, parameters.Existing.Id)
+                    .MapT(_ => parameters));
+
+    private static Task<Validation<BaseError, Parameters>> LocalLibraryMustExist(
+        TvContext dbContext,
+        UpdateLocalLibrary request) =>
+        dbContext.LocalLibraries
+            .Include(ll => ll.Paths)
+            .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.Id)
+            .MapT(
+                existing =>
+                {
+                    var incoming = new LocalLibrary
+                    {
+                        Name = request.Name,
+                        Paths = request.Paths.Map(p => new LibraryPath { Id = p.Id, Path = p.Path }).ToList(),
+                        MediaSourceId = existing.Id
+                    };
+
+                    return new Parameters(existing, incoming);
+                })
+            .Map(o => o.ToValidation<BaseError>("LocalLibrary does not exist."));
+
+    private record Parameters(LocalLibrary Existing, LocalLibrary Incoming);
+        
+    private static string NormalizePath(string path)
+    {
+        return Path.GetFullPath(new Uri(path).LocalPath)
+            .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
+            .ToUpperInvariant();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/LibraryViewModel.cs b/ErsatzTV.Application/Libraries/LibraryViewModel.cs
index 8fbe74c0f..cb3b52149 100644
--- a/ErsatzTV.Application/Libraries/LibraryViewModel.cs
+++ b/ErsatzTV.Application/Libraries/LibraryViewModel.cs
@@ -1,6 +1,5 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Libraries
-{
-    public record LibraryViewModel(string LibraryKind, int Id, string Name, LibraryMediaKind MediaKind);
-}
+namespace ErsatzTV.Application.Libraries;
+
+public record LibraryViewModel(string LibraryKind, int Id, string Name, LibraryMediaKind MediaKind);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/LocalLibraryPathViewModel.cs b/ErsatzTV.Application/Libraries/LocalLibraryPathViewModel.cs
index 9c8356bf8..54778c8f0 100644
--- a/ErsatzTV.Application/Libraries/LocalLibraryPathViewModel.cs
+++ b/ErsatzTV.Application/Libraries/LocalLibraryPathViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Libraries
-{
-    public record LocalLibraryPathViewModel(int Id, int LibraryId, string Path);
-}
+namespace ErsatzTV.Application.Libraries;
+
+public record LocalLibraryPathViewModel(int Id, int LibraryId, string Path);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/LocalLibraryViewModel.cs b/ErsatzTV.Application/Libraries/LocalLibraryViewModel.cs
index 5c51fc60a..64acf4140 100644
--- a/ErsatzTV.Application/Libraries/LocalLibraryViewModel.cs
+++ b/ErsatzTV.Application/Libraries/LocalLibraryViewModel.cs
@@ -1,7 +1,6 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Libraries
-{
-    public record LocalLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind)
-        : LibraryViewModel("Local", Id, Name, MediaKind);
-}
+namespace ErsatzTV.Application.Libraries;
+
+public record LocalLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind)
+    : LibraryViewModel("Local", Id, Name, MediaKind);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Mapper.cs b/ErsatzTV.Application/Libraries/Mapper.cs
index 42ff4ddc1..76e56856f 100644
--- a/ErsatzTV.Application/Libraries/Mapper.cs
+++ b/ErsatzTV.Application/Libraries/Mapper.cs
@@ -1,26 +1,24 @@
-using System;
-using ErsatzTV.Application.Emby;
+using ErsatzTV.Application.Emby;
 using ErsatzTV.Application.Jellyfin;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Libraries
+namespace ErsatzTV.Application.Libraries;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        public static LibraryViewModel ProjectToViewModel(Library library) =>
-            library switch
-            {
-                LocalLibrary l => ProjectToViewModel(l),
-                PlexLibrary p => new PlexLibraryViewModel(p.Id, p.Name, p.MediaKind),
-                JellyfinLibrary j => new JellyfinLibraryViewModel(j.Id, j.Name, j.MediaKind, j.ShouldSyncItems),
-                EmbyLibrary e => new EmbyLibraryViewModel(e.Id, e.Name, e.MediaKind, e.ShouldSyncItems),
-                _ => throw new ArgumentOutOfRangeException(nameof(library))
-            };
+    public static LibraryViewModel ProjectToViewModel(Library library) =>
+        library switch
+        {
+            LocalLibrary l => ProjectToViewModel(l),
+            PlexLibrary p => new PlexLibraryViewModel(p.Id, p.Name, p.MediaKind),
+            JellyfinLibrary j => new JellyfinLibraryViewModel(j.Id, j.Name, j.MediaKind, j.ShouldSyncItems),
+            EmbyLibrary e => new EmbyLibraryViewModel(e.Id, e.Name, e.MediaKind, e.ShouldSyncItems),
+            _ => throw new ArgumentOutOfRangeException(nameof(library))
+        };
 
-        public static LocalLibraryViewModel ProjectToViewModel(LocalLibrary library) =>
-            new(library.Id, library.Name, library.MediaKind);
+    public static LocalLibraryViewModel ProjectToViewModel(LocalLibrary library) =>
+        new(library.Id, library.Name, library.MediaKind);
 
-        public static LocalLibraryPathViewModel ProjectToViewModel(LibraryPath libraryPath) =>
-            new(libraryPath.Id, libraryPath.LibraryId, libraryPath.Path);
-    }
-}
+    public static LocalLibraryPathViewModel ProjectToViewModel(LibraryPath libraryPath) =>
+        new(libraryPath.Id, libraryPath.LibraryId, libraryPath.Path);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/PlexLibraryViewModel.cs b/ErsatzTV.Application/Libraries/PlexLibraryViewModel.cs
index 05d4be639..eabc26bb3 100644
--- a/ErsatzTV.Application/Libraries/PlexLibraryViewModel.cs
+++ b/ErsatzTV.Application/Libraries/PlexLibraryViewModel.cs
@@ -1,7 +1,6 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Libraries
-{
-    public record PlexLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind)
-        : LibraryViewModel("Plex", Id, Name, MediaKind);
-}
+namespace ErsatzTV.Application.Libraries;
+
+public record PlexLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind)
+    : LibraryViewModel("Plex", Id, Name, MediaKind);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibrary.cs b/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibrary.cs
index 51d0befa8..f7353132e 100644
--- a/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibrary.cs
+++ b/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibrary.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.Libraries;
 
-namespace ErsatzTV.Application.Libraries.Queries
-{
-    public record CountMediaItemsByLibrary(int LibraryId) : IRequest<int>;
-}
+public record CountMediaItemsByLibrary(int LibraryId) : IRequest<int>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryHandler.cs b/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryHandler.cs
index 8247a2139..44ee657ef 100644
--- a/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryHandler.cs
+++ b/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryHandler.cs
@@ -1,25 +1,21 @@
 using System.Data;
-using System.Threading;
-using System.Threading.Tasks;
 using Dapper;
-using MediatR;
 
-namespace ErsatzTV.Application.Libraries.Queries
+namespace ErsatzTV.Application.Libraries;
+
+public class CountMediaItemsByLibraryHandler : IRequestHandler<CountMediaItemsByLibrary, int>
 {
-    public class CountMediaItemsByLibraryHandler : IRequestHandler<CountMediaItemsByLibrary, int>
+    private readonly IDbConnection _dbConnection;
+
+    public CountMediaItemsByLibraryHandler(IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
+        _dbConnection = dbConnection;
+    }
 
-        public CountMediaItemsByLibraryHandler(IDbConnection dbConnection)
-        {
-            _dbConnection = dbConnection;
-        }
-
-        public Task<int> Handle(CountMediaItemsByLibrary request, CancellationToken cancellationToken) =>
-            _dbConnection.QuerySingleAsync<int>(
-                @"SELECT COUNT(*) FROM MediaItem
+    public Task<int> Handle(CountMediaItemsByLibrary request, CancellationToken cancellationToken) =>
+        _dbConnection.QuerySingleAsync<int>(
+            @"SELECT COUNT(*) FROM MediaItem
                   INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
                   WHERE LP.LibraryId = @LibraryId",
-                new { request.LibraryId });
-    }
-}
+            new { request.LibraryId });
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPath.cs b/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPath.cs
index 0b3d3b7d7..6f42896ca 100644
--- a/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPath.cs
+++ b/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPath.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.Libraries;
 
-namespace ErsatzTV.Application.Libraries.Queries
-{
-    public record CountMediaItemsByLibraryPath(int LibraryPathId) : IRequest<int>;
-}
+public record CountMediaItemsByLibraryPath(int LibraryPathId) : IRequest<int>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPathHandler.cs b/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPathHandler.cs
index 4b862af7c..398bc79bc 100644
--- a/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPathHandler.cs
+++ b/ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryPathHandler.cs
@@ -1,18 +1,14 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 
-namespace ErsatzTV.Application.Libraries.Queries
+namespace ErsatzTV.Application.Libraries;
+
+public class CountMediaItemsByLibraryPathHandler : IRequestHandler<CountMediaItemsByLibraryPath, int>
 {
-    public class CountMediaItemsByLibraryPathHandler : IRequestHandler<CountMediaItemsByLibraryPath, int>
-    {
-        private readonly ILibraryRepository _libraryRepository;
+    private readonly ILibraryRepository _libraryRepository;
 
-        public CountMediaItemsByLibraryPathHandler(ILibraryRepository libraryRepository) =>
-            _libraryRepository = libraryRepository;
+    public CountMediaItemsByLibraryPathHandler(ILibraryRepository libraryRepository) =>
+        _libraryRepository = libraryRepository;
 
-        public Task<int> Handle(CountMediaItemsByLibraryPath request, CancellationToken cancellationToken) =>
-            _libraryRepository.CountMediaItemsByPath(request.LibraryPathId);
-    }
-}
+    public Task<int> Handle(CountMediaItemsByLibraryPath request, CancellationToken cancellationToken) =>
+        _libraryRepository.CountMediaItemsByPath(request.LibraryPathId);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/GetAllLocalLibraries.cs b/ErsatzTV.Application/Libraries/Queries/GetAllLocalLibraries.cs
index 379b9f67d..28d3ff1ed 100644
--- a/ErsatzTV.Application/Libraries/Queries/GetAllLocalLibraries.cs
+++ b/ErsatzTV.Application/Libraries/Queries/GetAllLocalLibraries.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Libraries;
 
-namespace ErsatzTV.Application.Libraries.Queries
-{
-    public record GetAllLocalLibraries : IRequest<List<LocalLibraryViewModel>>;
-}
+public record GetAllLocalLibraries : IRequest<List<LocalLibraryViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/GetAllLocalLibrariesHandler.cs b/ErsatzTV.Application/Libraries/Queries/GetAllLocalLibrariesHandler.cs
index b30eef61a..b0b18efec 100644
--- a/ErsatzTV.Application/Libraries/Queries/GetAllLocalLibrariesHandler.cs
+++ b/ErsatzTV.Application/Libraries/Queries/GetAllLocalLibrariesHandler.cs
@@ -1,30 +1,23 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.Libraries.Mapper;
 
-namespace ErsatzTV.Application.Libraries.Queries
+namespace ErsatzTV.Application.Libraries;
+
+public class GetAllLocalLibrariesHandler : IRequestHandler<GetAllLocalLibraries, List<LocalLibraryViewModel>>
 {
-    public class GetAllLocalLibrariesHandler : IRequestHandler<GetAllLocalLibraries, List<LocalLibraryViewModel>>
-    {
-        private readonly ILibraryRepository _libraryRepository;
+    private readonly ILibraryRepository _libraryRepository;
 
-        public GetAllLocalLibrariesHandler(ILibraryRepository libraryRepository) => _libraryRepository = libraryRepository;
+    public GetAllLocalLibrariesHandler(ILibraryRepository libraryRepository) => _libraryRepository = libraryRepository;
 
-        public Task<List<LocalLibraryViewModel>> Handle(
-            GetAllLocalLibraries request,
-            CancellationToken cancellationToken) =>
-            _libraryRepository.GetAll()
-                .Map(
-                    list => list
-                        .OfType<LocalLibrary>()
-                        .OrderBy(l => l.MediaKind)
-                        .Map(ProjectToViewModel)
-                        .ToList());
-    }
-}
+    public Task<List<LocalLibraryViewModel>> Handle(
+        GetAllLocalLibraries request,
+        CancellationToken cancellationToken) =>
+        _libraryRepository.GetAll()
+            .Map(
+                list => list
+                    .OfType<LocalLibrary>()
+                    .OrderBy(l => l.MediaKind)
+                    .Map(ProjectToViewModel)
+                    .ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/GetConfiguredLibraries.cs b/ErsatzTV.Application/Libraries/Queries/GetConfiguredLibraries.cs
index eb12b8403..42e2779b5 100644
--- a/ErsatzTV.Application/Libraries/Queries/GetConfiguredLibraries.cs
+++ b/ErsatzTV.Application/Libraries/Queries/GetConfiguredLibraries.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Libraries;
 
-namespace ErsatzTV.Application.Libraries.Queries
-{
-    public record GetConfiguredLibraries : IRequest<List<LibraryViewModel>>;
-}
+public record GetConfiguredLibraries : IRequest<List<LibraryViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/GetConfiguredLibrariesHandler.cs b/ErsatzTV.Application/Libraries/Queries/GetConfiguredLibrariesHandler.cs
index f6999fa65..2187e1945 100644
--- a/ErsatzTV.Application/Libraries/Queries/GetConfiguredLibrariesHandler.cs
+++ b/ErsatzTV.Application/Libraries/Queries/GetConfiguredLibrariesHandler.cs
@@ -1,41 +1,34 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.Libraries.Mapper;
 
-namespace ErsatzTV.Application.Libraries.Queries
+namespace ErsatzTV.Application.Libraries;
+
+public class GetConfiguredLibrariesHandler : IRequestHandler<GetConfiguredLibraries, List<LibraryViewModel>>
 {
-    public class GetConfiguredLibrariesHandler : IRequestHandler<GetConfiguredLibraries, List<LibraryViewModel>>
-    {
-        private readonly ILibraryRepository _libraryRepository;
+    private readonly ILibraryRepository _libraryRepository;
 
-        public GetConfiguredLibrariesHandler(ILibraryRepository libraryRepository) =>
-            _libraryRepository = libraryRepository;
+    public GetConfiguredLibrariesHandler(ILibraryRepository libraryRepository) =>
+        _libraryRepository = libraryRepository;
 
-        public Task<List<LibraryViewModel>> Handle(
-            GetConfiguredLibraries request,
-            CancellationToken cancellationToken) =>
-            _libraryRepository.GetAll()
-                .Map(
-                    list => list.Filter(ShouldIncludeLibrary)
-                        .OrderBy(l => l.MediaSource is LocalMediaSource ? 0 : 1)
-                        .ThenBy(l => l.GetType().Name)
-                        .ThenBy(l => l.MediaKind)
-                        .Map(ProjectToViewModel).ToList());
+    public Task<List<LibraryViewModel>> Handle(
+        GetConfiguredLibraries request,
+        CancellationToken cancellationToken) =>
+        _libraryRepository.GetAll()
+            .Map(
+                list => list.Filter(ShouldIncludeLibrary)
+                    .OrderBy(l => l.MediaSource is LocalMediaSource ? 0 : 1)
+                    .ThenBy(l => l.GetType().Name)
+                    .ThenBy(l => l.MediaKind)
+                    .Map(ProjectToViewModel).ToList());
 
-        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 bool ShouldIncludeLibrary(Library library) =>
+        library switch
+        {
+            LocalLibrary => library.Paths.Count > 0,
+            PlexLibrary plex => plex.ShouldSyncItems,
+            JellyfinLibrary jellyfin => jellyfin.ShouldSyncItems,
+            EmbyLibrary emby => emby.ShouldSyncItems,
+            _ => false
+        };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryById.cs b/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryById.cs
index becb8e12c..229c46999 100644
--- a/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryById.cs
+++ b/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Libraries;
 
-namespace ErsatzTV.Application.Libraries.Queries
-{
-    public record GetLocalLibraryById(int LibraryId) : IRequest<Option<LocalLibraryViewModel>>;
-}
+public record GetLocalLibraryById(int LibraryId) : IRequest<Option<LocalLibraryViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryByIdHandler.cs b/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryByIdHandler.cs
index 6e9f111af..de85e1b7b 100644
--- a/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryByIdHandler.cs
@@ -1,22 +1,17 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Libraries.Mapper;
 
-namespace ErsatzTV.Application.Libraries.Queries
+namespace ErsatzTV.Application.Libraries;
+
+public class GetLocalLibraryByIdHandler : IRequestHandler<GetLocalLibraryById, Option<LocalLibraryViewModel>>
 {
-    public class GetLocalLibraryByIdHandler : IRequestHandler<GetLocalLibraryById, Option<LocalLibraryViewModel>>
-    {
-        private readonly ILibraryRepository _libraryRepository;
+    private readonly ILibraryRepository _libraryRepository;
 
-        public GetLocalLibraryByIdHandler(ILibraryRepository libraryRepository) =>
-            _libraryRepository = libraryRepository;
+    public GetLocalLibraryByIdHandler(ILibraryRepository libraryRepository) =>
+        _libraryRepository = libraryRepository;
 
-        public Task<Option<LocalLibraryViewModel>> Handle(
-            GetLocalLibraryById request,
-            CancellationToken cancellationToken) =>
-            _libraryRepository.GetLocal(request.LibraryId).MapT(ProjectToViewModel);
-    }
-}
+    public Task<Option<LocalLibraryViewModel>> Handle(
+        GetLocalLibraryById request,
+        CancellationToken cancellationToken) =>
+        _libraryRepository.GetLocal(request.LibraryId).MapT(ProjectToViewModel);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPaths.cs b/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPaths.cs
index 1bf34612b..46077f1f1 100644
--- a/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPaths.cs
+++ b/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPaths.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Libraries;
 
-namespace ErsatzTV.Application.Libraries.Queries
-{
-    public record GetLocalLibraryPaths(int LocalLibraryId) : IRequest<List<LocalLibraryPathViewModel>>;
-}
+public record GetLocalLibraryPaths(int LocalLibraryId) : IRequest<List<LocalLibraryPathViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPathsHandler.cs b/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPathsHandler.cs
index 517985a7f..c0f596ffb 100644
--- a/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPathsHandler.cs
+++ b/ErsatzTV.Application/Libraries/Queries/GetLocalLibraryPathsHandler.cs
@@ -1,25 +1,18 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Libraries.Mapper;
 
-namespace ErsatzTV.Application.Libraries.Queries
+namespace ErsatzTV.Application.Libraries;
+
+public class GetLocalLibraryPathsHandler : IRequestHandler<GetLocalLibraryPaths, List<LocalLibraryPathViewModel>>
 {
-    public class GetLocalLibraryPathsHandler : IRequestHandler<GetLocalLibraryPaths, List<LocalLibraryPathViewModel>>
-    {
-        private readonly ILibraryRepository _libraryRepository;
+    private readonly ILibraryRepository _libraryRepository;
 
-        public GetLocalLibraryPathsHandler(ILibraryRepository libraryRepository) =>
-            _libraryRepository = libraryRepository;
+    public GetLocalLibraryPathsHandler(ILibraryRepository libraryRepository) =>
+        _libraryRepository = libraryRepository;
 
-        public Task<List<LocalLibraryPathViewModel>> Handle(
-            GetLocalLibraryPaths request,
-            CancellationToken cancellationToken) =>
-            _libraryRepository.GetLocalPaths(request.LocalLibraryId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<LocalLibraryPathViewModel>> Handle(
+        GetLocalLibraryPaths request,
+        CancellationToken cancellationToken) =>
+        _libraryRepository.GetLocalPaths(request.LocalLibraryId)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Logs/LogEntryViewModel.cs b/ErsatzTV.Application/Logs/LogEntryViewModel.cs
index f94332a62..140d5a51d 100644
--- a/ErsatzTV.Application/Logs/LogEntryViewModel.cs
+++ b/ErsatzTV.Application/Logs/LogEntryViewModel.cs
@@ -1,12 +1,10 @@
-using System;
-using Serilog.Events;
+using Serilog.Events;
 
-namespace ErsatzTV.Application.Logs
-{
-    public record LogEntryViewModel(
-        int Id,
-        DateTime Timestamp,
-        LogEventLevel Level,
-        string Exception,
-        string Message);
-}
+namespace ErsatzTV.Application.Logs;
+
+public record LogEntryViewModel(
+    int Id,
+    DateTime Timestamp,
+    LogEventLevel Level,
+    string Exception,
+    string Message);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Logs/Mapper.cs b/ErsatzTV.Application/Logs/Mapper.cs
index 24b254a7b..3d55a3820 100644
--- a/ErsatzTV.Application/Logs/Mapper.cs
+++ b/ErsatzTV.Application/Logs/Mapper.cs
@@ -1,45 +1,42 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using Newtonsoft.Json.Linq;
 using Serilog.Events;
 
-namespace ErsatzTV.Application.Logs
-{
-    internal static class Mapper
-    {
-        internal static LogEntryViewModel ProjectToViewModel(LogEntry logEntry)
-        {
-            string message = logEntry.RenderedMessage;
-            if (!string.IsNullOrWhiteSpace(logEntry.Properties))
-            {
-                foreach (KeyValuePair<string, JToken> property in JObject.Parse(logEntry.Properties))
-                {
-                    var token = $"{{{property.Key}}}";
-                    if (message.Contains(token))
-                    {
-                        message = message.Replace(token, property.Value.ToString());
-                    }
+namespace ErsatzTV.Application.Logs;
 
-                    var destructureToken = $"{{@{property.Key}}}";
-                    if (message.Contains(destructureToken))
-                    {
-                        message = message.Replace(destructureToken, property.Value.ToString());
-                    }
+internal static class Mapper
+{
+    internal static LogEntryViewModel ProjectToViewModel(LogEntry logEntry)
+    {
+        string message = logEntry.RenderedMessage;
+        if (!string.IsNullOrWhiteSpace(logEntry.Properties))
+        {
+            foreach (KeyValuePair<string, JToken> property in JObject.Parse(logEntry.Properties))
+            {
+                var token = $"{{{property.Key}}}";
+                if (message.Contains(token))
+                {
+                    message = message.Replace(token, property.Value.ToString());
+                }
+
+                var destructureToken = $"{{@{property.Key}}}";
+                if (message.Contains(destructureToken))
+                {
+                    message = message.Replace(destructureToken, property.Value.ToString());
                 }
             }
-
-            if (!Enum.TryParse(logEntry.Level, out LogEventLevel level))
-            {
-                level = LogEventLevel.Debug;
-            }
-
-            return new LogEntryViewModel(
-                logEntry.Id,
-                logEntry.Timestamp,
-                level,
-                logEntry.Exception,
-                message);
         }
+
+        if (!Enum.TryParse(logEntry.Level, out LogEventLevel level))
+        {
+            level = LogEventLevel.Debug;
+        }
+
+        return new LogEntryViewModel(
+            logEntry.Id,
+            logEntry.Timestamp,
+            level,
+            logEntry.Exception,
+            message);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Logs/PagedLogEntriesViewModel.cs b/ErsatzTV.Application/Logs/PagedLogEntriesViewModel.cs
index 0bf8cb95d..6a343d644 100644
--- a/ErsatzTV.Application/Logs/PagedLogEntriesViewModel.cs
+++ b/ErsatzTV.Application/Logs/PagedLogEntriesViewModel.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.Logs;
 
-namespace ErsatzTV.Application.Logs
-{
-    public record PagedLogEntriesViewModel(int TotalCount, List<LogEntryViewModel> Page);
-}
+public record PagedLogEntriesViewModel(int TotalCount, List<LogEntryViewModel> Page);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Logs/Queries/GetRecentLogEntries.cs b/ErsatzTV.Application/Logs/Queries/GetRecentLogEntries.cs
index efd936b59..5344085df 100644
--- a/ErsatzTV.Application/Logs/Queries/GetRecentLogEntries.cs
+++ b/ErsatzTV.Application/Logs/Queries/GetRecentLogEntries.cs
@@ -1,14 +1,10 @@
-using System;
-using System.Linq.Expressions;
+using System.Linq.Expressions;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Logs.Queries
+namespace ErsatzTV.Application.Logs;
+
+public record GetRecentLogEntries(int PageNum, int PageSize) : IRequest<PagedLogEntriesViewModel>
 {
-    public record GetRecentLogEntries(int PageNum, int PageSize) : IRequest<PagedLogEntriesViewModel>
-    {
-        public Expression<Func<LogEntry, object>> SortExpression { get; set; }
-        public Option<bool> SortDescending { get; set; }
-    }
-}
+    public Expression<Func<LogEntry, object>> SortExpression { get; set; }
+    public Option<bool> SortDescending { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Logs/Queries/GetRecentLogEntriesHandler.cs b/ErsatzTV.Application/Logs/Queries/GetRecentLogEntriesHandler.cs
index 0df9f80da..bf7881f10 100644
--- a/ErsatzTV.Application/Logs/Queries/GetRecentLogEntriesHandler.cs
+++ b/ErsatzTV.Application/Logs/Queries/GetRecentLogEntriesHandler.cs
@@ -1,47 +1,40 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Logs.Mapper;
 
-namespace ErsatzTV.Application.Logs.Queries
+namespace ErsatzTV.Application.Logs;
+
+public class GetRecentLogEntriesHandler : IRequestHandler<GetRecentLogEntries, PagedLogEntriesViewModel>
 {
-    public class GetRecentLogEntriesHandler : IRequestHandler<GetRecentLogEntries, PagedLogEntriesViewModel>
+    private readonly IDbContextFactory<LogContext> _dbContextFactory;
+
+    public GetRecentLogEntriesHandler(IDbContextFactory<LogContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<PagedLogEntriesViewModel> Handle(
+        GetRecentLogEntries request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<LogContext> _dbContextFactory;
+        await using LogContext logContext = _dbContextFactory.CreateDbContext();
+        int count = await logContext.LogEntries.CountAsync(cancellationToken);
 
-        public GetRecentLogEntriesHandler(IDbContextFactory<LogContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        IOrderedQueryable<LogEntry> ordered = logContext.LogEntries
+            .OrderByDescending(le => le.Id);
 
-        public async Task<PagedLogEntriesViewModel> Handle(
-            GetRecentLogEntries request,
-            CancellationToken cancellationToken)
+        foreach (bool descending in request.SortDescending)
         {
-            await using LogContext logContext = _dbContextFactory.CreateDbContext();
-            int count = await logContext.LogEntries.CountAsync(cancellationToken);
-
-            IOrderedQueryable<LogEntry> ordered = logContext.LogEntries
-                .OrderByDescending(le => le.Id);
-
-            foreach (bool descending in request.SortDescending)
-            {
-                ordered = descending
-                    ? logContext.LogEntries.OrderByDescending(request.SortExpression).ThenByDescending(le => le.Id)
-                    : logContext.LogEntries.OrderBy(request.SortExpression).ThenByDescending(le => le.Id);
-            }
-
-            List<LogEntryViewModel> page = await ordered
-                .Skip(request.PageNum * request.PageSize)
-                .Take(request.PageSize)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-
-            return new PagedLogEntriesViewModel(count, page);
+            ordered = descending
+                ? logContext.LogEntries.OrderByDescending(request.SortExpression).ThenByDescending(le => le.Id)
+                : logContext.LogEntries.OrderBy(request.SortExpression).ThenByDescending(le => le.Id);
         }
+
+        List<LogEntryViewModel> page = await ordered
+            .Skip(request.PageNum * request.PageSize)
+            .Take(request.PageSize)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+
+        return new PagedLogEntriesViewModel(count, page);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabase.cs b/ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabase.cs
index 953c612f1..855dbb763 100644
--- a/ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabase.cs
+++ b/ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabase.cs
@@ -1,9 +1,5 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Maintenance.Commands;
+namespace ErsatzTV.Application.Maintenance;
 
 public record DeleteItemsFromDatabase(List<int> MediaItemIds) : IRequest<Either<BaseError, Unit>>;
diff --git a/ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabaseHandler.cs b/ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabaseHandler.cs
index 47d2dbc83..dc2bec2b3 100644
--- a/ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabaseHandler.cs
+++ b/ErsatzTV.Application/Maintenance/Commands/DeleteItemsFromDatabaseHandler.cs
@@ -1,38 +1,34 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Maintenance.Commands
+namespace ErsatzTV.Application.Maintenance;
+
+public class
+    DeleteItemsFromDatabaseHandler : MediatR.IRequestHandler<DeleteItemsFromDatabase, Either<BaseError, Unit>>
 {
-    public class
-        DeleteItemsFromDatabaseHandler : MediatR.IRequestHandler<DeleteItemsFromDatabase, Either<BaseError, Unit>>
+    private readonly IMediaItemRepository _mediaItemRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public DeleteItemsFromDatabaseHandler(
+        IMediaItemRepository mediaItemRepository,
+        ISearchIndex searchIndex)
     {
-        private readonly IMediaItemRepository _mediaItemRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public DeleteItemsFromDatabaseHandler(
-            IMediaItemRepository mediaItemRepository,
-            ISearchIndex searchIndex)
-        {
-            _mediaItemRepository = mediaItemRepository;
-            _searchIndex = searchIndex;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteItemsFromDatabase request,
-            CancellationToken cancellationToken)
-        {
-            Either<BaseError, Unit> deleteResult = await _mediaItemRepository.DeleteItems(request.MediaItemIds);
-            if (deleteResult.IsRight)
-            {
-                await _searchIndex.RemoveItems(request.MediaItemIds);
-                _searchIndex.Commit();
-            }
-
-            return deleteResult;
-        }
+        _mediaItemRepository = mediaItemRepository;
+        _searchIndex = searchIndex;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteItemsFromDatabase request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, Unit> deleteResult = await _mediaItemRepository.DeleteItems(request.MediaItemIds);
+        if (deleteResult.IsRight)
+        {
+            await _searchIndex.RemoveItems(request.MediaItemIds);
+            _searchIndex.Commit();
+        }
+
+        return deleteResult;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtwork.cs b/ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtwork.cs
index 8455fb8aa..9ab46be81 100644
--- a/ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtwork.cs
+++ b/ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtwork.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Maintenance.Commands
-{
-    public record DeleteOrphanedArtwork : MediatR.IRequest<Either<BaseError, Unit>>, IBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Maintenance;
+
+public record DeleteOrphanedArtwork : MediatR.IRequest<Either<BaseError, Unit>>, IBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtworkHandler.cs b/ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtworkHandler.cs
index 5cf2e26c2..41222782e 100644
--- a/ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtworkHandler.cs
+++ b/ErsatzTV.Application/Maintenance/Commands/DeleteOrphanedArtworkHandler.cs
@@ -1,23 +1,18 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Maintenance.Commands
+namespace ErsatzTV.Application.Maintenance;
+
+public class DeleteOrphanedArtworkHandler : MediatR.IRequestHandler<DeleteOrphanedArtwork, Either<BaseError, Unit>>
 {
-    public class DeleteOrphanedArtworkHandler : MediatR.IRequestHandler<DeleteOrphanedArtwork, Either<BaseError, Unit>>
-    {
-        private readonly IArtworkRepository _artworkRepository;
+    private readonly IArtworkRepository _artworkRepository;
 
-        public DeleteOrphanedArtworkHandler(IArtworkRepository artworkRepository) =>
-            _artworkRepository = artworkRepository;
+    public DeleteOrphanedArtworkHandler(IArtworkRepository artworkRepository) =>
+        _artworkRepository = artworkRepository;
 
-        public Task<Either<BaseError, Unit>>
-            Handle(DeleteOrphanedArtwork request, CancellationToken cancellationToken) =>
-            _artworkRepository.GetOrphanedArtwork()
-                .Bind(_artworkRepository.Delete)
-                .Map(_ => Right<BaseError, Unit>(Unit.Default));
-    }
-}
+    public Task<Either<BaseError, Unit>>
+        Handle(DeleteOrphanedArtwork request, CancellationToken cancellationToken) =>
+        _artworkRepository.GetOrphanedArtwork()
+            .Bind(_artworkRepository.Delete)
+            .Map(_ => Right<BaseError, Unit>(Unit.Default));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/ActorCardViewModel.cs b/ErsatzTV.Application/MediaCards/ActorCardViewModel.cs
index cb55ba658..f6cce92ca 100644
--- a/ErsatzTV.Application/MediaCards/ActorCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/ActorCardViewModel.cs
@@ -1,7 +1,6 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record ActorCardViewModel(int Id, string Name, string Role, string Thumb, MediaItemState State) :
-        MediaCardViewModel(Id, Name, Role, Name, Thumb, State);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record ActorCardViewModel(int Id, string Name, string Role, string Thumb, MediaItemState State) :
+    MediaCardViewModel(Id, Name, Role, Name, Thumb, State);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/ArtistCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/ArtistCardResultsViewModel.cs
index cc88a7bec..dc2522cb2 100644
--- a/ErsatzTV.Application/MediaCards/ArtistCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/ArtistCardResultsViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Search;
-using LanguageExt;
+using ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record ArtistCardResultsViewModel(
-        int Count,
-        List<ArtistCardViewModel> Cards,
-        Option<SearchPageMap> PageMap);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record ArtistCardResultsViewModel(
+    int Count,
+    List<ArtistCardViewModel> Cards,
+    Option<SearchPageMap> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs b/ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs
index 2dbef7bb8..74cc8b99f 100644
--- a/ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/ArtistCardViewModel.cs
@@ -1,19 +1,18 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record ArtistCardViewModel
-    (
-        int ArtistId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State) : MediaCardViewModel(
-        ArtistId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record ArtistCardViewModel
+(
+    int ArtistId,
+    string Title,
+    string Subtitle,
+    string SortTitle,
+    string Poster,
+    MediaItemState State) : MediaCardViewModel(
+    ArtistId,
+    Title,
+    Subtitle,
+    SortTitle,
+    Poster,
+    State);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs
index 820d167bc..ac9737603 100644
--- a/ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs
@@ -1,18 +1,15 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.MediaCards;
 
-namespace ErsatzTV.Application.MediaCards
+public record CollectionCardResultsViewModel(
+    string Name,
+    List<MovieCardViewModel> MovieCards,
+    List<TelevisionShowCardViewModel> ShowCards,
+    List<TelevisionSeasonCardViewModel> SeasonCards,
+    List<TelevisionEpisodeCardViewModel> EpisodeCards,
+    List<ArtistCardViewModel> ArtistCards,
+    List<MusicVideoCardViewModel> MusicVideoCards,
+    List<OtherVideoCardViewModel> OtherVideoCards,
+    List<SongCardViewModel> SongCards)
 {
-    public record CollectionCardResultsViewModel(
-        string Name,
-        List<MovieCardViewModel> MovieCards,
-        List<TelevisionShowCardViewModel> ShowCards,
-        List<TelevisionSeasonCardViewModel> SeasonCards,
-        List<TelevisionEpisodeCardViewModel> EpisodeCards,
-        List<ArtistCardViewModel> ArtistCards,
-        List<MusicVideoCardViewModel> MusicVideoCards,
-        List<OtherVideoCardViewModel> OtherVideoCards,
-        List<SongCardViewModel> SongCards)
-    {
-        public bool UseCustomPlaybackOrder { get; set; }
-    }
-}
+    public bool UseCustomPlaybackOrder { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Mapper.cs b/ErsatzTV.Application/MediaCards/Mapper.cs
index 305bf155b..1f4f262c4 100644
--- a/ErsatzTV.Application/MediaCards/Mapper.cs
+++ b/ErsatzTV.Application/MediaCards/Mapper.cs
@@ -1,263 +1,259 @@
-using System.Linq;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static TelevisionShowCardViewModel ProjectToViewModel(
-            ShowMetadata showMetadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby) =>
-            new(
-                showMetadata.ShowId,
-                showMetadata.Title,
-                showMetadata.Year?.ToString(),
-                showMetadata.SortTitle,
-                GetPoster(showMetadata, maybeJellyfin, maybeEmby),
-                showMetadata.Show.State);
+    internal static TelevisionShowCardViewModel ProjectToViewModel(
+        ShowMetadata showMetadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby) =>
+        new(
+            showMetadata.ShowId,
+            showMetadata.Title,
+            showMetadata.Year?.ToString(),
+            showMetadata.SortTitle,
+            GetPoster(showMetadata, maybeJellyfin, maybeEmby),
+            showMetadata.Show.State);
         
-        internal static TelevisionSeasonCardViewModel ProjectToViewModel(
-            Season season,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby) =>
-            new(
-                season.Show.ShowMetadata.HeadOrNone().Match(m => m.Title ?? string.Empty, () => string.Empty),
-                season.Id,
-                season.SeasonNumber,
-                GetSeasonName(season.SeasonNumber),
-                string.Empty,
-                GetSeasonName(season.SeasonNumber),
-                season.SeasonMetadata.HeadOrNone().Map(sm => GetPoster(sm, maybeJellyfin, maybeEmby))
-                    .IfNone(string.Empty),
-                season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString(),
-                season.State);
+    internal static TelevisionSeasonCardViewModel ProjectToViewModel(
+        Season season,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby) =>
+        new(
+            season.Show.ShowMetadata.HeadOrNone().Match(m => m.Title ?? string.Empty, () => string.Empty),
+            season.Id,
+            season.SeasonNumber,
+            GetSeasonName(season.SeasonNumber),
+            string.Empty,
+            GetSeasonName(season.SeasonNumber),
+            season.SeasonMetadata.HeadOrNone().Map(sm => GetPoster(sm, maybeJellyfin, maybeEmby))
+                .IfNone(string.Empty),
+            season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString(),
+            season.State);
 
-        internal static TelevisionSeasonCardViewModel ProjectToViewModel(
-            SeasonMetadata seasonMetadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby)
-        {
-            string showTitle = seasonMetadata.Season.Show.ShowMetadata.HeadOrNone().Match(
-                m => m.Title ?? string.Empty,
-                () => string.Empty);
+    internal static TelevisionSeasonCardViewModel ProjectToViewModel(
+        SeasonMetadata seasonMetadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby)
+    {
+        string showTitle = seasonMetadata.Season.Show.ShowMetadata.HeadOrNone().Match(
+            m => m.Title ?? string.Empty,
+            () => string.Empty);
 
-            return new TelevisionSeasonCardViewModel(
-                showTitle,
-                seasonMetadata.SeasonId,
-                seasonMetadata.Season.SeasonNumber,
-                showTitle,
-                GetSeasonName(seasonMetadata.Season.SeasonNumber),
-                $"{showTitle}_{seasonMetadata.Season.SeasonNumber:0000}",
-                GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
-                seasonMetadata.Season.SeasonNumber == 0 ? "S" : seasonMetadata.Season.SeasonNumber.ToString(),
-                seasonMetadata.Season.State);
-        }
-
-        internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
-            EpisodeMetadata episodeMetadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby,
-            bool isSearchResult) =>
-            new(
-                episodeMetadata.EpisodeId,
-                episodeMetadata.ReleaseDate ?? SystemTime.MinValueUtc,
-                episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone().Match(
-                    m => m.Title ?? string.Empty,
-                    () => string.Empty),
-                episodeMetadata.Episode.Season.ShowId,
-                episodeMetadata.Episode.SeasonId,
-                episodeMetadata.Episode.Season.SeasonNumber,
-                episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(em => em.EpisodeNumber, () => 0),
-                episodeMetadata.Title,
-                episodeMetadata.SortTitle,
-                episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(
-                    em => em.Plot ?? string.Empty,
-                    () => string.Empty),
-                isSearchResult
-                    ? GetEpisodePoster(episodeMetadata, maybeJellyfin, maybeEmby)
-                    : GetThumbnail(episodeMetadata, maybeJellyfin, maybeEmby),
-                episodeMetadata.Directors.Map(d => d.Name).ToList(),
-                episodeMetadata.Writers.Map(w => w.Name).ToList(),
-                episodeMetadata.Episode.State,
-                episodeMetadata.Episode.GetHeadVersion().MediaFiles.Head().Path);
-
-        internal static MovieCardViewModel ProjectToViewModel(
-            MovieMetadata movieMetadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby) =>
-            new(
-                movieMetadata.MovieId,
-                movieMetadata.Title,
-                movieMetadata.Year?.ToString(),
-                movieMetadata.SortTitle,
-                GetPoster(movieMetadata, maybeJellyfin, maybeEmby),
-                movieMetadata.Movie.State);
-
-        internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
-            new(
-                musicVideoMetadata.MusicVideoId,
-                musicVideoMetadata.Title,
-                musicVideoMetadata.MusicVideo.Artist.ArtistMetadata.Head().Title,
-                musicVideoMetadata.SortTitle,
-                musicVideoMetadata.Plot,
-                musicVideoMetadata.Album,
-                GetThumbnail(musicVideoMetadata, None, None),
-                musicVideoMetadata.MusicVideo.State,
-                musicVideoMetadata.MusicVideo.GetHeadVersion().MediaFiles.Head().Path);
-
-        internal static OtherVideoCardViewModel ProjectToViewModel(OtherVideoMetadata otherVideoMetadata) =>
-            new(
-                otherVideoMetadata.OtherVideoId,
-                otherVideoMetadata.Title,
-                otherVideoMetadata.OriginalTitle,
-                otherVideoMetadata.SortTitle,
-                otherVideoMetadata.OtherVideo.State);
-
-        internal static SongCardViewModel ProjectToViewModel(SongMetadata songMetadata)
-        {
-            string album = string.IsNullOrWhiteSpace(songMetadata.Album) ? "" : $" - {songMetadata.Album}";
-            return new SongCardViewModel(
-                songMetadata.SongId,
-                songMetadata.Title,
-                songMetadata.Artist + album,
-                songMetadata.SortTitle,
-                GetThumbnail(songMetadata, None, None),
-                songMetadata.Song.State);
-        }
-
-        internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
-            new(
-                artistMetadata.ArtistId,
-                artistMetadata.Title,
-                artistMetadata.Disambiguation,
-                artistMetadata.SortTitle,
-                GetThumbnail(artistMetadata, None, None),
-                artistMetadata.Artist.State);
-
-        internal static CollectionCardResultsViewModel
-            ProjectToViewModel(
-                Collection collection,
-                Option<JellyfinMediaSource> maybeJellyfin,
-                Option<EmbyMediaSource> maybeEmby) =>
-            new(
-                collection.Name,
-                collection.MediaItems.OfType<Movie>().Map(
-                    m => ProjectToViewModel(m.MovieMetadata.Head(), maybeJellyfin, maybeEmby) with
-                    {
-                        CustomIndex = GetCustomIndex(collection, m.Id)
-                    }).ToList(),
-                collection.MediaItems.OfType<Show>()
-                    .Map(s => ProjectToViewModel(s.ShowMetadata.Head(), maybeJellyfin, maybeEmby))
-                    .ToList(),
-                collection.MediaItems.OfType<Season>().Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby))
-                    .ToList(),
-                collection.MediaItems.OfType<Episode>()
-                    .Map(e => ProjectToViewModel(e.EpisodeMetadata.Head(), maybeJellyfin, maybeEmby, false))
-                    .ToList(),
-                collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
-                collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
-                    .ToList(),
-                collection.MediaItems.OfType<OtherVideo>().Map(ov => ProjectToViewModel(ov.OtherVideoMetadata.Head()))
-                    .ToList(),
-                collection.MediaItems.OfType<Song>().Map(s => ProjectToViewModel(s.SongMetadata.Head()))
-                    .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
-
-        internal static ActorCardViewModel ProjectToViewModel(
-            Actor actor,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby)
-        {
-            string artwork = actor.Artwork?.Path ?? string.Empty;
-
-            if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
-            {
-                artwork = JellyfinUrl.RelativeProxyForArtwork(artwork)
-                    .SetQueryParam("fillHeight", 440);
-            }
-            else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
-            {
-                artwork = EmbyUrl.RelativeProxyForArtwork(artwork)
-                    .SetQueryParam("maxHeight", 440);
-            }
-
-            return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork, MediaItemState.Normal);
-        }
-
-        private static int GetCustomIndex(Collection collection, int mediaItemId) =>
-            Optional(collection.CollectionItems.Find(ci => ci.MediaItemId == mediaItemId))
-                .Map(ci => ci.CustomIndex ?? 0)
-                .IfNone(0);
-
-        private static string GetSeasonName(int number) =>
-            number == 0 ? "Specials" : $"Season {number}";
-
-        private static string GetEpisodePoster(
-            EpisodeMetadata episodeMetadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby)
-        {
-            Option<SeasonMetadata> maybeSeasonMetadata = episodeMetadata.Episode.Season.SeasonMetadata.HeadOrNone();
-            return maybeSeasonMetadata.Match(
-                seasonMetadata => GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
-                () =>
-                {
-                    Option<ShowMetadata> maybeShowMetadata =
-                        episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone();
-                    return maybeShowMetadata.Match(
-                        showMetadata => GetPoster(showMetadata, maybeJellyfin, maybeEmby),
-                        () => string.Empty);
-                });
-        }
-
-        private static string GetPoster(
-            Metadata metadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby)
-        {
-            string poster = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster))
-                .Match(a => a.Path, string.Empty);
-
-            if (maybeJellyfin.IsSome && poster.StartsWith("jellyfin://"))
-            {
-                poster = JellyfinUrl.RelativeProxyForArtwork(poster)
-                    .SetQueryParam("fillHeight", 440);
-            }
-            else if (maybeEmby.IsSome && poster.StartsWith("emby://"))
-            {
-                poster = EmbyUrl.RelativeProxyForArtwork(poster)
-                    .SetQueryParam("maxHeight", 440);
-            }
-
-            return poster;
-        }
-
-        private static string GetThumbnail(
-            Metadata metadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby)
-        {
-            string thumb = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail))
-                .Match(a => a.Path, string.Empty);
-
-            if (maybeJellyfin.IsSome && thumb.StartsWith("jellyfin://"))
-            {
-                thumb = JellyfinUrl.RelativeProxyForArtwork(thumb)
-                    .SetQueryParam("fillHeight", 220);
-            }
-            else if (maybeEmby.IsSome && thumb.StartsWith("emby://"))
-            {
-                thumb = EmbyUrl.RelativeProxyForArtwork(thumb)
-                    .SetQueryParam("maxHeight", 220);
-            }
-
-            return thumb;
-        }
+        return new TelevisionSeasonCardViewModel(
+            showTitle,
+            seasonMetadata.SeasonId,
+            seasonMetadata.Season.SeasonNumber,
+            showTitle,
+            GetSeasonName(seasonMetadata.Season.SeasonNumber),
+            $"{showTitle}_{seasonMetadata.Season.SeasonNumber:0000}",
+            GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
+            seasonMetadata.Season.SeasonNumber == 0 ? "S" : seasonMetadata.Season.SeasonNumber.ToString(),
+            seasonMetadata.Season.State);
     }
-}
+
+    internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
+        EpisodeMetadata episodeMetadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby,
+        bool isSearchResult) =>
+        new(
+            episodeMetadata.EpisodeId,
+            episodeMetadata.ReleaseDate ?? SystemTime.MinValueUtc,
+            episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone().Match(
+                m => m.Title ?? string.Empty,
+                () => string.Empty),
+            episodeMetadata.Episode.Season.ShowId,
+            episodeMetadata.Episode.SeasonId,
+            episodeMetadata.Episode.Season.SeasonNumber,
+            episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(em => em.EpisodeNumber, () => 0),
+            episodeMetadata.Title,
+            episodeMetadata.SortTitle,
+            episodeMetadata.Episode.EpisodeMetadata.HeadOrNone().Match(
+                em => em.Plot ?? string.Empty,
+                () => string.Empty),
+            isSearchResult
+                ? GetEpisodePoster(episodeMetadata, maybeJellyfin, maybeEmby)
+                : GetThumbnail(episodeMetadata, maybeJellyfin, maybeEmby),
+            episodeMetadata.Directors.Map(d => d.Name).ToList(),
+            episodeMetadata.Writers.Map(w => w.Name).ToList(),
+            episodeMetadata.Episode.State,
+            episodeMetadata.Episode.GetHeadVersion().MediaFiles.Head().Path);
+
+    internal static MovieCardViewModel ProjectToViewModel(
+        MovieMetadata movieMetadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby) =>
+        new(
+            movieMetadata.MovieId,
+            movieMetadata.Title,
+            movieMetadata.Year?.ToString(),
+            movieMetadata.SortTitle,
+            GetPoster(movieMetadata, maybeJellyfin, maybeEmby),
+            movieMetadata.Movie.State);
+
+    internal static MusicVideoCardViewModel ProjectToViewModel(MusicVideoMetadata musicVideoMetadata) =>
+        new(
+            musicVideoMetadata.MusicVideoId,
+            musicVideoMetadata.Title,
+            musicVideoMetadata.MusicVideo.Artist.ArtistMetadata.Head().Title,
+            musicVideoMetadata.SortTitle,
+            musicVideoMetadata.Plot,
+            musicVideoMetadata.Album,
+            GetThumbnail(musicVideoMetadata, None, None),
+            musicVideoMetadata.MusicVideo.State,
+            musicVideoMetadata.MusicVideo.GetHeadVersion().MediaFiles.Head().Path);
+
+    internal static OtherVideoCardViewModel ProjectToViewModel(OtherVideoMetadata otherVideoMetadata) =>
+        new(
+            otherVideoMetadata.OtherVideoId,
+            otherVideoMetadata.Title,
+            otherVideoMetadata.OriginalTitle,
+            otherVideoMetadata.SortTitle,
+            otherVideoMetadata.OtherVideo.State);
+
+    internal static SongCardViewModel ProjectToViewModel(SongMetadata songMetadata)
+    {
+        string album = string.IsNullOrWhiteSpace(songMetadata.Album) ? "" : $" - {songMetadata.Album}";
+        return new SongCardViewModel(
+            songMetadata.SongId,
+            songMetadata.Title,
+            songMetadata.Artist + album,
+            songMetadata.SortTitle,
+            GetThumbnail(songMetadata, None, None),
+            songMetadata.Song.State);
+    }
+
+    internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
+        new(
+            artistMetadata.ArtistId,
+            artistMetadata.Title,
+            artistMetadata.Disambiguation,
+            artistMetadata.SortTitle,
+            GetThumbnail(artistMetadata, None, None),
+            artistMetadata.Artist.State);
+
+    internal static CollectionCardResultsViewModel
+        ProjectToViewModel(
+            Collection collection,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby) =>
+        new(
+            collection.Name,
+            collection.MediaItems.OfType<Movie>().Map(
+                m => ProjectToViewModel(m.MovieMetadata.Head(), maybeJellyfin, maybeEmby) with
+                {
+                    CustomIndex = GetCustomIndex(collection, m.Id)
+                }).ToList(),
+            collection.MediaItems.OfType<Show>()
+                .Map(s => ProjectToViewModel(s.ShowMetadata.Head(), maybeJellyfin, maybeEmby))
+                .ToList(),
+            collection.MediaItems.OfType<Season>().Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby))
+                .ToList(),
+            collection.MediaItems.OfType<Episode>()
+                .Map(e => ProjectToViewModel(e.EpisodeMetadata.Head(), maybeJellyfin, maybeEmby, false))
+                .ToList(),
+            collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
+            collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
+                .ToList(),
+            collection.MediaItems.OfType<OtherVideo>().Map(ov => ProjectToViewModel(ov.OtherVideoMetadata.Head()))
+                .ToList(),
+            collection.MediaItems.OfType<Song>().Map(s => ProjectToViewModel(s.SongMetadata.Head()))
+                .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };
+
+    internal static ActorCardViewModel ProjectToViewModel(
+        Actor actor,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby)
+    {
+        string artwork = actor.Artwork?.Path ?? string.Empty;
+
+        if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
+        {
+            artwork = JellyfinUrl.RelativeProxyForArtwork(artwork)
+                .SetQueryParam("fillHeight", 440);
+        }
+        else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
+        {
+            artwork = EmbyUrl.RelativeProxyForArtwork(artwork)
+                .SetQueryParam("maxHeight", 440);
+        }
+
+        return new ActorCardViewModel(actor.Id, actor.Name, actor.Role, artwork, MediaItemState.Normal);
+    }
+
+    private static int GetCustomIndex(Collection collection, int mediaItemId) =>
+        Optional(collection.CollectionItems.Find(ci => ci.MediaItemId == mediaItemId))
+            .Map(ci => ci.CustomIndex ?? 0)
+            .IfNone(0);
+
+    private static string GetSeasonName(int number) =>
+        number == 0 ? "Specials" : $"Season {number}";
+
+    private static string GetEpisodePoster(
+        EpisodeMetadata episodeMetadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby)
+    {
+        Option<SeasonMetadata> maybeSeasonMetadata = episodeMetadata.Episode.Season.SeasonMetadata.HeadOrNone();
+        return maybeSeasonMetadata.Match(
+            seasonMetadata => GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
+            () =>
+            {
+                Option<ShowMetadata> maybeShowMetadata =
+                    episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone();
+                return maybeShowMetadata.Match(
+                    showMetadata => GetPoster(showMetadata, maybeJellyfin, maybeEmby),
+                    () => string.Empty);
+            });
+    }
+
+    private static string GetPoster(
+        Metadata metadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby)
+    {
+        string poster = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster))
+            .Match(a => a.Path, string.Empty);
+
+        if (maybeJellyfin.IsSome && poster.StartsWith("jellyfin://"))
+        {
+            poster = JellyfinUrl.RelativeProxyForArtwork(poster)
+                .SetQueryParam("fillHeight", 440);
+        }
+        else if (maybeEmby.IsSome && poster.StartsWith("emby://"))
+        {
+            poster = EmbyUrl.RelativeProxyForArtwork(poster)
+                .SetQueryParam("maxHeight", 440);
+        }
+
+        return poster;
+    }
+
+    private static string GetThumbnail(
+        Metadata metadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby)
+    {
+        string thumb = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail))
+            .Match(a => a.Path, string.Empty);
+
+        if (maybeJellyfin.IsSome && thumb.StartsWith("jellyfin://"))
+        {
+            thumb = JellyfinUrl.RelativeProxyForArtwork(thumb)
+                .SetQueryParam("fillHeight", 220);
+        }
+        else if (maybeEmby.IsSome && thumb.StartsWith("emby://"))
+        {
+            thumb = EmbyUrl.RelativeProxyForArtwork(thumb)
+                .SetQueryParam("maxHeight", 220);
+        }
+
+        return thumb;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/MediaCardViewModel.cs b/ErsatzTV.Application/MediaCards/MediaCardViewModel.cs
index 1f9112318..db68dd45b 100644
--- a/ErsatzTV.Application/MediaCards/MediaCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/MediaCardViewModel.cs
@@ -1,12 +1,11 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record MediaCardViewModel(
-        int MediaItemId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record MediaCardViewModel(
+    int MediaItemId,
+    string Title,
+    string Subtitle,
+    string SortTitle,
+    string Poster,
+    MediaItemState State);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/MovieCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/MovieCardResultsViewModel.cs
index 6f07386f2..e2906452c 100644
--- a/ErsatzTV.Application/MediaCards/MovieCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/MovieCardResultsViewModel.cs
@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Search;
-using LanguageExt;
+using ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record MovieCardResultsViewModel(int Count, List<MovieCardViewModel> Cards, Option<SearchPageMap> PageMap);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record MovieCardResultsViewModel(int Count, List<MovieCardViewModel> Cards, Option<SearchPageMap> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/MovieCardViewModel.cs b/ErsatzTV.Application/MediaCards/MovieCardViewModel.cs
index 47641b8c8..71e4e9690 100644
--- a/ErsatzTV.Application/MediaCards/MovieCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/MovieCardViewModel.cs
@@ -1,22 +1,21 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards;
+
+public record MovieCardViewModel
+(
+    int MovieId,
+    string Title,
+    string Subtitle,
+    string SortTitle,
+    string Poster,
+    MediaItemState State) : MediaCardViewModel(
+    MovieId,
+    Title,
+    Subtitle,
+    SortTitle,
+    Poster,
+    State)
 {
-    public record MovieCardViewModel
-    (
-        int MovieId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State) : MediaCardViewModel(
-        MovieId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State)
-    {
-        public int CustomIndex { get; set; }
-    }
-}
+    public int CustomIndex { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/MusicVideoCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/MusicVideoCardResultsViewModel.cs
index ff0816da9..4d11cfac8 100644
--- a/ErsatzTV.Application/MediaCards/MusicVideoCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/MusicVideoCardResultsViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Search;
-using LanguageExt;
+using ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record MusicVideoCardResultsViewModel(
-        int Count,
-        List<MusicVideoCardViewModel> Cards,
-        Option<SearchPageMap> PageMap);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record MusicVideoCardResultsViewModel(
+    int Count,
+    List<MusicVideoCardViewModel> Cards,
+    Option<SearchPageMap> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs b/ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs
index c7aa360eb..ebe4824fa 100644
--- a/ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs
@@ -1,25 +1,24 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards;
+
+public record MusicVideoCardViewModel
+(
+    int MusicVideoId,
+    string Title,
+    string Subtitle,
+    string SortTitle,
+    string Plot,
+    string Album,
+    string Poster,
+    MediaItemState State,
+    string Path) : MediaCardViewModel(
+    MusicVideoId,
+    Title,
+    Subtitle,
+    SortTitle,
+    Poster,
+    State)
 {
-    public record MusicVideoCardViewModel
-    (
-        int MusicVideoId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Plot,
-        string Album,
-        string Poster,
-        MediaItemState State,
-        string Path) : MediaCardViewModel(
-        MusicVideoId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State)
-    {
-        public int CustomIndex { get; set; }
-    }
-}
+    public int CustomIndex { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs
index b48437df2..45b9585ef 100644
--- a/ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Search;
-using LanguageExt;
+using ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record OtherVideoCardResultsViewModel(
-        int Count,
-        List<OtherVideoCardViewModel> Cards,
-        Option<SearchPageMap> PageMap);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record OtherVideoCardResultsViewModel(
+    int Count,
+    List<OtherVideoCardViewModel> Cards,
+    Option<SearchPageMap> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs b/ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs
index d75cc863b..a4092658e 100644
--- a/ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs
@@ -1,21 +1,20 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards;
+
+public record OtherVideoCardViewModel
+(
+    int OtherVideoId,
+    string Title,
+    string Subtitle,
+    string SortTitle,
+    MediaItemState State) : MediaCardViewModel(
+    OtherVideoId,
+    Title,
+    Subtitle,
+    SortTitle,
+    null,
+    State)
 {
-    public record OtherVideoCardViewModel
-    (
-        int OtherVideoId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        MediaItemState State) : MediaCardViewModel(
-        OtherVideoId,
-        Title,
-        Subtitle,
-        SortTitle,
-        null,
-        State)
-    {
-        public int CustomIndex { get; set; }
-    }
-}
+    public int CustomIndex { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Queries/GetCollectionCards.cs b/ErsatzTV.Application/MediaCards/Queries/GetCollectionCards.cs
index 210276295..bf3b80d58 100644
--- a/ErsatzTV.Application/MediaCards/Queries/GetCollectionCards.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetCollectionCards.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public record GetCollectionCards(int Id) : IRequest<Either<BaseError, CollectionCardResultsViewModel>>;
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record GetCollectionCards(int Id) : IRequest<Either<BaseError, CollectionCardResultsViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs b/ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs
index 8a118cc30..215212a4a 100644
--- a/ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs
@@ -1,109 +1,104 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.MediaCards.Queries
+namespace ErsatzTV.Application.MediaCards;
+
+public class GetCollectionCardsHandler :
+    IRequestHandler<GetCollectionCards, Either<BaseError, CollectionCardResultsViewModel>>
 {
-    public class GetCollectionCardsHandler :
-        IRequestHandler<GetCollectionCards, Either<BaseError, CollectionCardResultsViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public GetCollectionCardsHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-
-        public GetCollectionCardsHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<Either<BaseError, CollectionCardResultsViewModel>> Handle(
-            GetCollectionCards request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            return await dbContext.Collections
-                .AsNoTracking()
-                .Include(c => c.CollectionItems)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => i.LibraryPath)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Movie).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Artist).ArtistMetadata)
-                .ThenInclude(mvm => mvm.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as MusicVideo).Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as MusicVideo).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Show).ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Season).SeasonMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Season).Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Directors)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Writers)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.SeasonMetadata)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Episode).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
-                .ThenInclude(ovm => ovm.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as OtherVideo).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(ovm => ovm.Artwork)
-                .Include(c => c.MediaItems)
-                .ThenInclude(i => (i as Song).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
-                .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
-                .MapT(c => ProjectToViewModel(c, maybeJellyfin, maybeEmby));
-        }
+        _dbContextFactory = dbContextFactory;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<Either<BaseError, CollectionCardResultsViewModel>> Handle(
+        GetCollectionCards request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        return await dbContext.Collections
+            .AsNoTracking()
+            .Include(c => c.CollectionItems)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => i.LibraryPath)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Movie).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Artist).ArtistMetadata)
+            .ThenInclude(mvm => mvm.Artwork)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Artwork)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as MusicVideo).Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as MusicVideo).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Show).ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Season).SeasonMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Season).Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Artwork)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Directors)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Writers)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.SeasonMetadata)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Episode).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+            .ThenInclude(ovm => ovm.Artwork)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as OtherVideo).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(ovm => ovm.Artwork)
+            .Include(c => c.MediaItems)
+            .ThenInclude(i => (i as Song).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
+            .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
+            .MapT(c => ProjectToViewModel(c, maybeJellyfin, maybeEmby));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCards.cs b/ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCards.cs
index 71564a568..2399f57a9 100644
--- a/ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCards.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCards.cs
@@ -1,7 +1,4 @@
-using MediatR;
+namespace ErsatzTV.Application.MediaCards;
 
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public record GetMusicVideoCards
-        (int ArtistId, int PageNumber, int PageSize) : IRequest<MusicVideoCardResultsViewModel>;
-}
+public record GetMusicVideoCards
+    (int ArtistId, int PageNumber, int PageSize) : IRequest<MusicVideoCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCardsHandler.cs b/ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCardsHandler.cs
index b47c62879..6ff72922b 100644
--- a/ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCardsHandler.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetMusicVideoCardsHandler.cs
@@ -1,33 +1,25 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.MediaCards.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCards.Queries
+namespace ErsatzTV.Application.MediaCards;
+
+public class GetMusicVideoCardsHandler : IRequestHandler<GetMusicVideoCards, MusicVideoCardResultsViewModel>
 {
-    public class GetMusicVideoCardsHandler : IRequestHandler<GetMusicVideoCards, MusicVideoCardResultsViewModel>
+    private readonly IMusicVideoRepository _musicVideoRepository;
+
+    public GetMusicVideoCardsHandler(IMusicVideoRepository musicVideoRepository) =>
+        _musicVideoRepository = musicVideoRepository;
+
+    public async Task<MusicVideoCardResultsViewModel> Handle(
+        GetMusicVideoCards request,
+        CancellationToken cancellationToken)
     {
-        private readonly IMusicVideoRepository _musicVideoRepository;
+        int count = await _musicVideoRepository.GetMusicVideoCount(request.ArtistId);
 
-        public GetMusicVideoCardsHandler(IMusicVideoRepository musicVideoRepository) =>
-            _musicVideoRepository = musicVideoRepository;
+        List<MusicVideoCardViewModel> results = await _musicVideoRepository
+            .GetPagedMusicVideos(request.ArtistId, request.PageNumber, request.PageSize)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 
-        public async Task<MusicVideoCardResultsViewModel> Handle(
-            GetMusicVideoCards request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _musicVideoRepository.GetMusicVideoCount(request.ArtistId);
-
-            List<MusicVideoCardViewModel> results = await _musicVideoRepository
-                .GetPagedMusicVideos(request.ArtistId, request.PageNumber, request.PageSize)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-
-            return new MusicVideoCardResultsViewModel(count, results, None);
-        }
+        return new MusicVideoCardResultsViewModel(count, results, None);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCards.cs b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCards.cs
index b6aa3cc51..3a18d5b69 100644
--- a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCards.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCards.cs
@@ -1,7 +1,4 @@
-using MediatR;
+namespace ErsatzTV.Application.MediaCards;
 
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public record GetTelevisionEpisodeCards
-        (int TelevisionSeasonId, int PageNumber, int PageSize) : IRequest<TelevisionEpisodeCardResultsViewModel>;
-}
+public record GetTelevisionEpisodeCards
+    (int TelevisionSeasonId, int PageNumber, int PageSize) : IRequest<TelevisionEpisodeCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCardsHandler.cs b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCardsHandler.cs
index 97607c779..3863ca021 100644
--- a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCardsHandler.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionEpisodeCardsHandler.cs
@@ -1,48 +1,41 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.MediaCards.Queries
+namespace ErsatzTV.Application.MediaCards;
+
+public class
+    GetTelevisionEpisodeCardsHandler : IRequestHandler<GetTelevisionEpisodeCards,
+        TelevisionEpisodeCardResultsViewModel>
 {
-    public class
-        GetTelevisionEpisodeCardsHandler : IRequestHandler<GetTelevisionEpisodeCards,
-            TelevisionEpisodeCardResultsViewModel>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public GetTelevisionEpisodeCardsHandler(
+        ITelevisionRepository televisionRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public GetTelevisionEpisodeCardsHandler(
-            ITelevisionRepository televisionRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _televisionRepository = televisionRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<TelevisionEpisodeCardResultsViewModel> Handle(
-            GetTelevisionEpisodeCards request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _televisionRepository.GetEpisodeCount(request.TelevisionSeasonId);
-
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            List<TelevisionEpisodeCardViewModel> results = await _televisionRepository
-                .GetPagedEpisodes(request.TelevisionSeasonId, request.PageNumber, request.PageSize)
-                .Map(list => list.Map(e => ProjectToViewModel(e, maybeJellyfin, maybeEmby, false)).ToList());
-
-            return new TelevisionEpisodeCardResultsViewModel(count, results, Option<SearchPageMap>.None);
-        }
+        _televisionRepository = televisionRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<TelevisionEpisodeCardResultsViewModel> Handle(
+        GetTelevisionEpisodeCards request,
+        CancellationToken cancellationToken)
+    {
+        int count = await _televisionRepository.GetEpisodeCount(request.TelevisionSeasonId);
+
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        List<TelevisionEpisodeCardViewModel> results = await _televisionRepository
+            .GetPagedEpisodes(request.TelevisionSeasonId, request.PageNumber, request.PageSize)
+            .Map(list => list.Map(e => ProjectToViewModel(e, maybeJellyfin, maybeEmby, false)).ToList());
+
+        return new TelevisionEpisodeCardResultsViewModel(count, results, Option<SearchPageMap>.None);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCards.cs b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCards.cs
index 85f7546fb..20cfeabd2 100644
--- a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCards.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCards.cs
@@ -1,7 +1,4 @@
-using MediatR;
+namespace ErsatzTV.Application.MediaCards;
 
-namespace ErsatzTV.Application.MediaCards.Queries
-{
-    public record GetTelevisionSeasonCards
-        (int TelevisionShowId, int PageNumber, int PageSize) : IRequest<TelevisionSeasonCardResultsViewModel>;
-}
+public record GetTelevisionSeasonCards
+    (int TelevisionShowId, int PageNumber, int PageSize) : IRequest<TelevisionSeasonCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs
index 2eb386a2c..61d3b5a54 100644
--- a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs
@@ -1,48 +1,40 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCards.Queries
+namespace ErsatzTV.Application.MediaCards;
+
+public class
+    GetTelevisionSeasonCardsHandler : IRequestHandler<GetTelevisionSeasonCards,
+        TelevisionSeasonCardResultsViewModel>
 {
-    public class
-        GetTelevisionSeasonCardsHandler : IRequestHandler<GetTelevisionSeasonCards,
-            TelevisionSeasonCardResultsViewModel>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public GetTelevisionSeasonCardsHandler(
+        ITelevisionRepository televisionRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public GetTelevisionSeasonCardsHandler(
-            ITelevisionRepository televisionRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _televisionRepository = televisionRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<TelevisionSeasonCardResultsViewModel> Handle(
-            GetTelevisionSeasonCards request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _televisionRepository.GetSeasonCount(request.TelevisionShowId);
-
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            List<TelevisionSeasonCardViewModel> results = await _televisionRepository
-                .GetPagedSeasons(request.TelevisionShowId, request.PageNumber, request.PageSize)
-                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
-
-            return new TelevisionSeasonCardResultsViewModel(count, results, None);
-        }
+        _televisionRepository = televisionRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<TelevisionSeasonCardResultsViewModel> Handle(
+        GetTelevisionSeasonCards request,
+        CancellationToken cancellationToken)
+    {
+        int count = await _televisionRepository.GetSeasonCount(request.TelevisionShowId);
+
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        List<TelevisionSeasonCardViewModel> results = await _televisionRepository
+            .GetPagedSeasons(request.TelevisionShowId, request.PageNumber, request.PageSize)
+            .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
+
+        return new TelevisionSeasonCardResultsViewModel(count, results, None);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/SearchCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/SearchCardResultsViewModel.cs
index e84f3c413..88be2d8a6 100644
--- a/ErsatzTV.Application/MediaCards/SearchCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/SearchCardResultsViewModel.cs
@@ -1,8 +1,5 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.MediaCards;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record SearchCardResultsViewModel(
-        List<MovieCardViewModel> MovieCards,
-        List<TelevisionShowCardViewModel> ShowCards);
-}
+public record SearchCardResultsViewModel(
+    List<MovieCardViewModel> MovieCards,
+    List<TelevisionShowCardViewModel> ShowCards);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/SongCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/SongCardResultsViewModel.cs
index e2b8f71b4..eca3dc2cb 100644
--- a/ErsatzTV.Application/MediaCards/SongCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/SongCardResultsViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Search;
-using LanguageExt;
+using ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record SongCardResultsViewModel(
-        int Count,
-        List<SongCardViewModel> Cards,
-        Option<SearchPageMap> PageMap);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record SongCardResultsViewModel(
+    int Count,
+    List<SongCardViewModel> Cards,
+    Option<SearchPageMap> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/SongCardViewModel.cs b/ErsatzTV.Application/MediaCards/SongCardViewModel.cs
index f755b8c6d..b1a02141a 100644
--- a/ErsatzTV.Application/MediaCards/SongCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/SongCardViewModel.cs
@@ -1,22 +1,21 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
+namespace ErsatzTV.Application.MediaCards;
+
+public record SongCardViewModel
+(
+    int SongId,
+    string Title,
+    string Subtitle,
+    string SortTitle,
+    string Poster,
+    MediaItemState State) : MediaCardViewModel(
+    SongId,
+    Title,
+    Subtitle,
+    SortTitle,
+    Poster,
+    State)
 {
-    public record SongCardViewModel
-    (
-        int SongId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State) : MediaCardViewModel(
-        SongId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State)
-    {
-        public int CustomIndex { get; set; }
-    }
-}
+    public int CustomIndex { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/TelevisionEpisodeCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/TelevisionEpisodeCardResultsViewModel.cs
index bec3054a2..af3c11ccd 100644
--- a/ErsatzTV.Application/MediaCards/TelevisionEpisodeCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/TelevisionEpisodeCardResultsViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Search;
-using LanguageExt;
+using ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record TelevisionEpisodeCardResultsViewModel(
-        int Count,
-        List<TelevisionEpisodeCardViewModel> Cards,
-        Option<SearchPageMap> PageMap);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record TelevisionEpisodeCardResultsViewModel(
+    int Count,
+    List<TelevisionEpisodeCardViewModel> Cards,
+    Option<SearchPageMap> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs b/ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs
index 8f0f7b614..5d47f6c2e 100644
--- a/ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/TelevisionEpisodeCardViewModel.cs
@@ -1,30 +1,27 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record TelevisionEpisodeCardViewModel
-    (
-        int EpisodeId,
-        DateTime Aired,
-        string ShowTitle,
-        int ShowId,
-        int SeasonId,
-        int Season,
-        int Episode,
-        string Title,
-        string SortTitle,
-        string Plot,
-        string Poster,
-        List<string> Directors,
-        List<string> Writers,
-        MediaItemState State,
-        string Path) : MediaCardViewModel(
-        EpisodeId,
-        Title,
-        $"Episode {Episode}",
-        SortTitle,
-        Poster,
-        State);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record TelevisionEpisodeCardViewModel
+(
+    int EpisodeId,
+    DateTime Aired,
+    string ShowTitle,
+    int ShowId,
+    int SeasonId,
+    int Season,
+    int Episode,
+    string Title,
+    string SortTitle,
+    string Plot,
+    string Poster,
+    List<string> Directors,
+    List<string> Writers,
+    MediaItemState State,
+    string Path) : MediaCardViewModel(
+    EpisodeId,
+    Title,
+    $"Episode {Episode}",
+    SortTitle,
+    Poster,
+    State);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs
index 028935af2..c3a2d2057 100644
--- a/ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Search;
-using LanguageExt;
+using ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record TelevisionSeasonCardResultsViewModel(
-        int Count,
-        List<TelevisionSeasonCardViewModel> Cards,
-        Option<SearchPageMap> PageMap);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record TelevisionSeasonCardResultsViewModel(
+    int Count,
+    List<TelevisionSeasonCardViewModel> Cards,
+    Option<SearchPageMap> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs b/ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs
index 65dc96e47..d2f42db14 100644
--- a/ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/TelevisionSeasonCardViewModel.cs
@@ -1,22 +1,21 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record TelevisionSeasonCardViewModel
-    (
-        string ShowTitle,
-        int TelevisionSeasonId,
-        int TelevisionSeasonNumber,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        string Placeholder,
-        MediaItemState State) : MediaCardViewModel(
-        TelevisionSeasonId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record TelevisionSeasonCardViewModel
+(
+    string ShowTitle,
+    int TelevisionSeasonId,
+    int TelevisionSeasonNumber,
+    string Title,
+    string Subtitle,
+    string SortTitle,
+    string Poster,
+    string Placeholder,
+    MediaItemState State) : MediaCardViewModel(
+    TelevisionSeasonId,
+    Title,
+    Subtitle,
+    SortTitle,
+    Poster,
+    State);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/TelevisionShowCardResultsViewModel.cs b/ErsatzTV.Application/MediaCards/TelevisionShowCardResultsViewModel.cs
index 1d8cee3c4..3e1264369 100644
--- a/ErsatzTV.Application/MediaCards/TelevisionShowCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/TelevisionShowCardResultsViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Search;
-using LanguageExt;
+using ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record TelevisionShowCardResultsViewModel(
-        int Count,
-        List<TelevisionShowCardViewModel> Cards,
-        Option<SearchPageMap> PageMap);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record TelevisionShowCardResultsViewModel(
+    int Count,
+    List<TelevisionShowCardViewModel> Cards,
+    Option<SearchPageMap> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs b/ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs
index b7e86eac3..3aee93167 100644
--- a/ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/TelevisionShowCardViewModel.cs
@@ -1,19 +1,18 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCards
-{
-    public record TelevisionShowCardViewModel
-    (
-        int TelevisionShowId,
-        string Title,
-        string Subtitle,
-        string SortTitle,
-        string Poster,
-        MediaItemState State) : MediaCardViewModel(
-        TelevisionShowId,
-        Title,
-        Subtitle,
-        SortTitle,
-        Poster,
-        State);
-}
+namespace ErsatzTV.Application.MediaCards;
+
+public record TelevisionShowCardViewModel
+(
+    int TelevisionShowId,
+    string Title,
+    string Subtitle,
+    string SortTitle,
+    string Poster,
+    MediaItemState State) : MediaCardViewModel(
+    TelevisionShowId,
+    Title,
+    Subtitle,
+    SortTitle,
+    Poster,
+    State);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollection.cs
index 328a8af4a..c2711031b 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollection.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddArtistToCollection
-        (int CollectionId, int ArtistId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddArtistToCollection
+    (int CollectionId, int ArtistId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.cs
index 99470520a..e27fe6931 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.cs
@@ -1,80 +1,76 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddArtistToCollectionHandler :
+    MediatR.IRequestHandler<AddArtistToCollection, Either<BaseError, Unit>>
 {
-    public class AddArtistToCollectionHandler :
-        MediatR.IRequestHandler<AddArtistToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public AddArtistToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public AddArtistToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddArtistToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => ApplyAddArtistRequest(dbContext, parameters));
-        }
-
-        private async Task<Unit> ApplyAddArtistRequest(TvContext dbContext, Parameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.Artist);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            AddArtistToCollection request) =>
-            (await CollectionMustExist(dbContext, request), await ValidateArtist(dbContext, request))
-            .Apply((collection, artist) => new Parameters(collection, artist));
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddArtistToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Task<Validation<BaseError, Artist>> ValidateArtist(
-            TvContext dbContext,
-            AddArtistToCollection request) =>
-            dbContext.Artists
-                .SelectOneAsync(a => a.Id, a => a.Id == request.ArtistId)
-                .Map(o => o.ToValidation<BaseError>("Artist does not exist"));
-
-        private record Parameters(Collection Collection, Artist Artist);
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddArtistToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => ApplyAddArtistRequest(dbContext, parameters));
+    }
+
+    private async Task<Unit> ApplyAddArtistRequest(TvContext dbContext, Parameters parameters)
+    {
+        parameters.Collection.MediaItems.Add(parameters.Artist);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        AddArtistToCollection request) =>
+        (await CollectionMustExist(dbContext, request), await ValidateArtist(dbContext, request))
+        .Apply((collection, artist) => new Parameters(collection, artist));
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddArtistToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Task<Validation<BaseError, Artist>> ValidateArtist(
+        TvContext dbContext,
+        AddArtistToCollection request) =>
+        dbContext.Artists
+            .SelectOneAsync(a => a.Id, a => a.Id == request.ArtistId)
+            .Map(o => o.ToValidation<BaseError>("Artist does not exist"));
+
+    private record Parameters(Collection Collection, Artist Artist);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollection.cs
index ae69c119c..79ce6509f 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollection.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddEpisodeToCollection(int CollectionId, int EpisodeId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddEpisodeToCollection(int CollectionId, int EpisodeId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollectionHandler.cs
index 625d013e2..1db8dd485 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddEpisodeToCollectionHandler.cs
@@ -1,80 +1,76 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddEpisodeToCollectionHandler :
+    MediatR.IRequestHandler<AddEpisodeToCollection, Either<BaseError, Unit>>
 {
-    public class AddEpisodeToCollectionHandler :
-        MediatR.IRequestHandler<AddEpisodeToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public AddEpisodeToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public AddEpisodeToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddEpisodeToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => ApplyAddTelevisionEpisodeRequest(dbContext, parameters));
-        }
-
-        private async Task<Unit> ApplyAddTelevisionEpisodeRequest(TvContext dbContext, Parameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.Episode);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            AddEpisodeToCollection request) =>
-            (await CollectionMustExist(dbContext, request), await ValidateEpisode(dbContext, request))
-            .Apply((collection, episode) => new Parameters(collection, episode));
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddEpisodeToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Task<Validation<BaseError, Episode>> ValidateEpisode(
-            TvContext dbContext,
-            AddEpisodeToCollection request) =>
-            dbContext.Episodes
-                .SelectOneAsync(e => e.Id, e => e.Id == request.EpisodeId)
-                .Map(o => o.ToValidation<BaseError>("Episode does not exist"));
-
-        private record Parameters(Collection Collection, Episode Episode);
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddEpisodeToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => ApplyAddTelevisionEpisodeRequest(dbContext, parameters));
+    }
+
+    private async Task<Unit> ApplyAddTelevisionEpisodeRequest(TvContext dbContext, Parameters parameters)
+    {
+        parameters.Collection.MediaItems.Add(parameters.Episode);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        AddEpisodeToCollection request) =>
+        (await CollectionMustExist(dbContext, request), await ValidateEpisode(dbContext, request))
+        .Apply((collection, episode) => new Parameters(collection, episode));
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddEpisodeToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Task<Validation<BaseError, Episode>> ValidateEpisode(
+        TvContext dbContext,
+        AddEpisodeToCollection request) =>
+        dbContext.Episodes
+            .SelectOneAsync(e => e.Id, e => e.Id == request.EpisodeId)
+            .Map(o => o.ToValidation<BaseError>("Episode does not exist"));
+
+    private record Parameters(Collection Collection, Episode Episode);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs
index 1c5302f17..aada16a44 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs
@@ -1,18 +1,15 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddItemsToCollection
-    (
-        int CollectionId,
-        List<int> MovieIds,
-        List<int> ShowIds,
-        List<int> SeasonIds,
-        List<int> EpisodeIds,
-        List<int> ArtistIds,
-        List<int> MusicVideoIds,
-        List<int> OtherVideoIds,
-        List<int> SongIds) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddItemsToCollection
+(
+    int CollectionId,
+    List<int> MovieIds,
+    List<int> ShowIds,
+    List<int> SeasonIds,
+    List<int> EpisodeIds,
+    List<int> ArtistIds,
+    List<int> MusicVideoIds,
+    List<int> OtherVideoIds,
+    List<int> SongIds) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs
index 59fcf4280..a2fbdd222 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs
@@ -1,129 +1,122 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddItemsToCollectionHandler :
+    MediatR.IRequestHandler<AddItemsToCollection, Either<BaseError, Unit>>
 {
-    public class AddItemsToCollectionHandler :
-        MediatR.IRequestHandler<AddItemsToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+    private readonly IMovieRepository _movieRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public AddItemsToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        IMovieRepository movieRepository,
+        ITelevisionRepository televisionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-        private readonly IMovieRepository _movieRepository;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public AddItemsToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            IMovieRepository movieRepository,
-            ITelevisionRepository televisionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _movieRepository = movieRepository;
-            _televisionRepository = televisionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddItemsToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyAddItemsRequest(dbContext, c, request));
-        }
-
-        private async Task<Unit> ApplyAddItemsRequest(TvContext dbContext, Collection collection, AddItemsToCollection request)
-        {
-            var allItems = request.MovieIds
-                .Append(request.ShowIds)
-                .Append(request.SeasonIds)
-                .Append(request.EpisodeIds)
-                .Append(request.ArtistIds)
-                .Append(request.MusicVideoIds)
-                .Append(request.OtherVideoIds)
-                .Append(request.SongIds)
-                .ToList();
-
-            var toAddIds = allItems.Where(item => collection.MediaItems.All(mi => mi.Id != item)).ToList();
-            List<MediaItem> toAdd = await dbContext.MediaItems
-                .Filter(mi => toAddIds.Contains(mi.Id))
-                .ToListAsync();
-
-            collection.MediaItems.AddRange(toAdd);
-
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(request.CollectionId))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private async Task<Validation<BaseError, Collection>> Validate(
-            TvContext dbContext,
-            AddItemsToCollection request) =>
-            (await CollectionMustExist(dbContext, request),
-                await ValidateMovies(request),
-                await ValidateShows(request),
-                await ValidateSeasons(request),
-                await ValidateEpisodes(request))
-            .Apply((collection, _, _, _, _) => collection);
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddItemsToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private Task<Validation<BaseError, Unit>> ValidateMovies(AddItemsToCollection request) =>
-            _movieRepository.AllMoviesExist(request.MovieIds)
-                .Map(Optional)
-                .Filter(v => v == true)
-                .MapT(_ => Unit.Default)
-                .Map(v => v.ToValidation<BaseError>("Movie does not exist"));
-
-        private Task<Validation<BaseError, Unit>> ValidateShows(AddItemsToCollection request) =>
-            _televisionRepository.AllShowsExist(request.ShowIds)
-                .Map(Optional)
-                .Filter(v => v == true)
-                .MapT(_ => Unit.Default)
-                .Map(v => v.ToValidation<BaseError>("Show does not exist"));
-
-        private Task<Validation<BaseError, Unit>> ValidateSeasons(AddItemsToCollection request) =>
-            _televisionRepository.AllSeasonsExist(request.SeasonIds)
-                .Map(Optional)
-                .Filter(v => v == true)
-                .MapT(_ => Unit.Default)
-                .Map(v => v.ToValidation<BaseError>("Season does not exist"));
-
-        private Task<Validation<BaseError, Unit>> ValidateEpisodes(AddItemsToCollection request) =>
-            _televisionRepository.AllEpisodesExist(request.EpisodeIds)
-                .Map(Optional)
-                .Filter(v => v == true)
-                .MapT(_ => Unit.Default)
-                .Map(v => v.ToValidation<BaseError>("Episode does not exist"));
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _movieRepository = movieRepository;
+        _televisionRepository = televisionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddItemsToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        Validation<BaseError, Collection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => ApplyAddItemsRequest(dbContext, c, request));
+    }
+
+    private async Task<Unit> ApplyAddItemsRequest(TvContext dbContext, Collection collection, AddItemsToCollection request)
+    {
+        var allItems = request.MovieIds
+            .Append(request.ShowIds)
+            .Append(request.SeasonIds)
+            .Append(request.EpisodeIds)
+            .Append(request.ArtistIds)
+            .Append(request.MusicVideoIds)
+            .Append(request.OtherVideoIds)
+            .Append(request.SongIds)
+            .ToList();
+
+        var toAddIds = allItems.Where(item => collection.MediaItems.All(mi => mi.Id != item)).ToList();
+        List<MediaItem> toAdd = await dbContext.MediaItems
+            .Filter(mi => toAddIds.Contains(mi.Id))
+            .ToListAsync();
+
+        collection.MediaItems.AddRange(toAdd);
+
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(request.CollectionId))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private async Task<Validation<BaseError, Collection>> Validate(
+        TvContext dbContext,
+        AddItemsToCollection request) =>
+        (await CollectionMustExist(dbContext, request),
+            await ValidateMovies(request),
+            await ValidateShows(request),
+            await ValidateSeasons(request),
+            await ValidateEpisodes(request))
+        .Apply((collection, _, _, _, _) => collection);
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddItemsToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private Task<Validation<BaseError, Unit>> ValidateMovies(AddItemsToCollection request) =>
+        _movieRepository.AllMoviesExist(request.MovieIds)
+            .Map(Optional)
+            .Filter(v => v == true)
+            .MapT(_ => Unit.Default)
+            .Map(v => v.ToValidation<BaseError>("Movie does not exist"));
+
+    private Task<Validation<BaseError, Unit>> ValidateShows(AddItemsToCollection request) =>
+        _televisionRepository.AllShowsExist(request.ShowIds)
+            .Map(Optional)
+            .Filter(v => v == true)
+            .MapT(_ => Unit.Default)
+            .Map(v => v.ToValidation<BaseError>("Show does not exist"));
+
+    private Task<Validation<BaseError, Unit>> ValidateSeasons(AddItemsToCollection request) =>
+        _televisionRepository.AllSeasonsExist(request.SeasonIds)
+            .Map(Optional)
+            .Filter(v => v == true)
+            .MapT(_ => Unit.Default)
+            .Map(v => v.ToValidation<BaseError>("Season does not exist"));
+
+    private Task<Validation<BaseError, Unit>> ValidateEpisodes(AddItemsToCollection request) =>
+        _televisionRepository.AllEpisodesExist(request.EpisodeIds)
+            .Map(Optional)
+            .Filter(v => v == true)
+            .MapT(_ => Unit.Default)
+            .Map(v => v.ToValidation<BaseError>("Episode does not exist"));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddMovieCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddMovieCollection.cs
index e9bc90deb..2ee69d58d 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddMovieCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddMovieCollection.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddMovieToCollection(int CollectionId, int MovieId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddMovieToCollection(int CollectionId, int MovieId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddMovieToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddMovieToCollectionHandler.cs
index 7c92ec84b..11b8616e5 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddMovieToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddMovieToCollectionHandler.cs
@@ -1,80 +1,76 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddMovieToCollectionHandler :
+    MediatR.IRequestHandler<AddMovieToCollection, Either<BaseError, Unit>>
 {
-    public class AddMovieToCollectionHandler :
-        MediatR.IRequestHandler<AddMovieToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public AddMovieToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public AddMovieToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddMovieToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => ApplyAddMovieRequest(dbContext, parameters));
-        }
-
-        private async Task<Unit> ApplyAddMovieRequest(TvContext dbContext, Parameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.Movie);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            AddMovieToCollection request) =>
-            (await CollectionMustExist(dbContext, request), await ValidateMovie(dbContext, request))
-            .Apply((collection, episode) => new Parameters(collection, episode));
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddMovieToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Task<Validation<BaseError, Movie>> ValidateMovie(
-            TvContext dbContext,
-            AddMovieToCollection request) =>
-            dbContext.Movies
-                .SelectOneAsync(m => m.Id, e => e.Id == request.MovieId)
-                .Map(o => o.ToValidation<BaseError>("Movie does not exist"));
-
-        private record Parameters(Collection Collection, Movie Movie);
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddMovieToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => ApplyAddMovieRequest(dbContext, parameters));
+    }
+
+    private async Task<Unit> ApplyAddMovieRequest(TvContext dbContext, Parameters parameters)
+    {
+        parameters.Collection.MediaItems.Add(parameters.Movie);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        AddMovieToCollection request) =>
+        (await CollectionMustExist(dbContext, request), await ValidateMovie(dbContext, request))
+        .Apply((collection, episode) => new Parameters(collection, episode));
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddMovieToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Task<Validation<BaseError, Movie>> ValidateMovie(
+        TvContext dbContext,
+        AddMovieToCollection request) =>
+        dbContext.Movies
+            .SelectOneAsync(m => m.Id, e => e.Id == request.MovieId)
+            .Map(o => o.ToValidation<BaseError>("Movie does not exist"));
+
+    private record Parameters(Collection Collection, Movie Movie);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollection.cs
index b89e902ba..279206f58 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollection.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddMusicVideoToCollection
-        (int CollectionId, int MusicVideoId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddMusicVideoToCollection
+    (int CollectionId, int MusicVideoId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollectionHandler.cs
index b21b3408f..d4a359136 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddMusicVideoToCollectionHandler.cs
@@ -1,80 +1,76 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddMusicVideoToCollectionHandler :
+    MediatR.IRequestHandler<AddMusicVideoToCollection, Either<BaseError, Unit>>
 {
-    public class AddMusicVideoToCollectionHandler :
-        MediatR.IRequestHandler<AddMusicVideoToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public AddMusicVideoToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public AddMusicVideoToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddMusicVideoToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => ApplyAddMusicVideoRequest(dbContext, parameters));
-        }
-
-        private async Task<Unit> ApplyAddMusicVideoRequest(TvContext dbContext, Parameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.MusicVideo);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            AddMusicVideoToCollection request) =>
-            (await CollectionMustExist(dbContext, request), await ValidateMusicVideo(dbContext, request))
-            .Apply((collection, episode) => new Parameters(collection, episode));
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddMusicVideoToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Task<Validation<BaseError, MusicVideo>> ValidateMusicVideo(
-            TvContext dbContext,
-            AddMusicVideoToCollection request) =>
-            dbContext.MusicVideos
-                .SelectOneAsync(m => m.Id, e => e.Id == request.MusicVideoId)
-                .Map(o => o.ToValidation<BaseError>("MusicVideo does not exist"));
-
-        private record Parameters(Collection Collection, MusicVideo MusicVideo);
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddMusicVideoToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => ApplyAddMusicVideoRequest(dbContext, parameters));
+    }
+
+    private async Task<Unit> ApplyAddMusicVideoRequest(TvContext dbContext, Parameters parameters)
+    {
+        parameters.Collection.MediaItems.Add(parameters.MusicVideo);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        AddMusicVideoToCollection request) =>
+        (await CollectionMustExist(dbContext, request), await ValidateMusicVideo(dbContext, request))
+        .Apply((collection, episode) => new Parameters(collection, episode));
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddMusicVideoToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Task<Validation<BaseError, MusicVideo>> ValidateMusicVideo(
+        TvContext dbContext,
+        AddMusicVideoToCollection request) =>
+        dbContext.MusicVideos
+            .SelectOneAsync(m => m.Id, e => e.Id == request.MusicVideoId)
+            .Map(o => o.ToValidation<BaseError>("MusicVideo does not exist"));
+
+    private record Parameters(Collection Collection, MusicVideo MusicVideo);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs
index cc017345f..c44310190 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddOtherVideoToCollection
-        (int CollectionId, int OtherVideoId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddOtherVideoToCollection
+    (int CollectionId, int OtherVideoId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs
index ffa8d1059..24313e6bd 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs
@@ -1,80 +1,76 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddOtherVideoToCollectionHandler :
+    MediatR.IRequestHandler<AddOtherVideoToCollection, Either<BaseError, Unit>>
 {
-    public class AddOtherVideoToCollectionHandler :
-        MediatR.IRequestHandler<AddOtherVideoToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public AddOtherVideoToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public AddOtherVideoToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddOtherVideoToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => ApplyAddOtherVideoRequest(dbContext, parameters));
-        }
-
-        private async Task<Unit> ApplyAddOtherVideoRequest(TvContext dbContext, Parameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.OtherVideo);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            AddOtherVideoToCollection request) =>
-            (await CollectionMustExist(dbContext, request), await ValidateOtherVideo(dbContext, request))
-            .Apply((collection, episode) => new Parameters(collection, episode));
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddOtherVideoToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Task<Validation<BaseError, OtherVideo>> ValidateOtherVideo(
-            TvContext dbContext,
-            AddOtherVideoToCollection request) =>
-            dbContext.OtherVideos
-                .SelectOneAsync(m => m.Id, e => e.Id == request.OtherVideoId)
-                .Map(o => o.ToValidation<BaseError>("OtherVideo does not exist"));
-
-        private record Parameters(Collection Collection, OtherVideo OtherVideo);
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddOtherVideoToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => ApplyAddOtherVideoRequest(dbContext, parameters));
+    }
+
+    private async Task<Unit> ApplyAddOtherVideoRequest(TvContext dbContext, Parameters parameters)
+    {
+        parameters.Collection.MediaItems.Add(parameters.OtherVideo);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        AddOtherVideoToCollection request) =>
+        (await CollectionMustExist(dbContext, request), await ValidateOtherVideo(dbContext, request))
+        .Apply((collection, episode) => new Parameters(collection, episode));
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddOtherVideoToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Task<Validation<BaseError, OtherVideo>> ValidateOtherVideo(
+        TvContext dbContext,
+        AddOtherVideoToCollection request) =>
+        dbContext.OtherVideos
+            .SelectOneAsync(m => m.Id, e => e.Id == request.OtherVideoId)
+            .Map(o => o.ToValidation<BaseError>("OtherVideo does not exist"));
+
+    private record Parameters(Collection Collection, OtherVideo OtherVideo);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollection.cs
index e3f795f82..57d43c27f 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollection.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddSeasonToCollection(int CollectionId, int SeasonId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddSeasonToCollection(int CollectionId, int SeasonId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollectionHandler.cs
index f5d3e3952..893b463d1 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddSeasonToCollectionHandler.cs
@@ -1,80 +1,76 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddSeasonToCollectionHandler :
+    MediatR.IRequestHandler<AddSeasonToCollection, Either<BaseError, Unit>>
 {
-    public class AddSeasonToCollectionHandler :
-        MediatR.IRequestHandler<AddSeasonToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public AddSeasonToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public AddSeasonToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddSeasonToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => ApplyAddSeasonRequest(dbContext, parameters));
-        }
-
-        private async Task<Unit> ApplyAddSeasonRequest(TvContext dbContext, Parameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.Season);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            AddSeasonToCollection request) =>
-            (await CollectionMustExist(dbContext, request), await ValidateSeason(dbContext, request))
-            .Apply((collection, episode) => new Parameters(collection, episode));
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddSeasonToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Task<Validation<BaseError, Season>> ValidateSeason(
-            TvContext dbContext,
-            AddSeasonToCollection request) =>
-            dbContext.Seasons
-                .SelectOneAsync(m => m.Id, e => e.Id == request.SeasonId)
-                .Map(o => o.ToValidation<BaseError>("Season does not exist"));
-
-        private record Parameters(Collection Collection, Season Season);
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddSeasonToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => ApplyAddSeasonRequest(dbContext, parameters));
+    }
+
+    private async Task<Unit> ApplyAddSeasonRequest(TvContext dbContext, Parameters parameters)
+    {
+        parameters.Collection.MediaItems.Add(parameters.Season);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        AddSeasonToCollection request) =>
+        (await CollectionMustExist(dbContext, request), await ValidateSeason(dbContext, request))
+        .Apply((collection, episode) => new Parameters(collection, episode));
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddSeasonToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Task<Validation<BaseError, Season>> ValidateSeason(
+        TvContext dbContext,
+        AddSeasonToCollection request) =>
+        dbContext.Seasons
+            .SelectOneAsync(m => m.Id, e => e.Id == request.SeasonId)
+            .Map(o => o.ToValidation<BaseError>("Season does not exist"));
+
+    private record Parameters(Collection Collection, Season Season);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddShowToCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddShowToCollection.cs
index 48233e6d4..476e29123 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddShowToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddShowToCollection.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddShowToCollection(int CollectionId, int ShowId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddShowToCollection(int CollectionId, int ShowId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddShowToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddShowToCollectionHandler.cs
index adee60732..a6ea3bfd2 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddShowToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddShowToCollectionHandler.cs
@@ -1,80 +1,76 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddShowToCollectionHandler :
+    MediatR.IRequestHandler<AddShowToCollection, Either<BaseError, Unit>>
 {
-    public class AddShowToCollectionHandler :
-        MediatR.IRequestHandler<AddShowToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public AddShowToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public AddShowToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddShowToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => ApplyAddShowRequest(dbContext, parameters));
-        }
-
-        private async Task<Unit> ApplyAddShowRequest(TvContext dbContext, Parameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.Show);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            AddShowToCollection request) =>
-            (await CollectionMustExist(dbContext, request), await ValidateShow(dbContext, request))
-            .Apply((collection, episode) => new Parameters(collection, episode));
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddShowToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Task<Validation<BaseError, Show>> ValidateShow(
-            TvContext dbContext,
-            AddShowToCollection request) =>
-            dbContext.Shows
-                .SelectOneAsync(m => m.Id, e => e.Id == request.ShowId)
-                .Map(o => o.ToValidation<BaseError>("Show does not exist"));
-
-        private record Parameters(Collection Collection, Show Show);
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddShowToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => ApplyAddShowRequest(dbContext, parameters));
+    }
+
+    private async Task<Unit> ApplyAddShowRequest(TvContext dbContext, Parameters parameters)
+    {
+        parameters.Collection.MediaItems.Add(parameters.Show);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        AddShowToCollection request) =>
+        (await CollectionMustExist(dbContext, request), await ValidateShow(dbContext, request))
+        .Apply((collection, episode) => new Parameters(collection, episode));
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddShowToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Task<Validation<BaseError, Show>> ValidateShow(
+        TvContext dbContext,
+        AddShowToCollection request) =>
+        dbContext.Shows
+            .SelectOneAsync(m => m.Id, e => e.Id == request.ShowId)
+            .Map(o => o.ToValidation<BaseError>("Show does not exist"));
+
+    private record Parameters(Collection Collection, Show Show);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollection.cs
index f99ed854b..5bd9c0edf 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollection.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddSongToCollection
-        (int CollectionId, int SongId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddSongToCollection
+    (int CollectionId, int SongId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollectionHandler.cs
index c1ce55245..69a277e6d 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollectionHandler.cs
@@ -1,80 +1,76 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddSongToCollectionHandler :
+    MediatR.IRequestHandler<AddSongToCollection, Either<BaseError, Unit>>
 {
-    public class AddSongToCollectionHandler :
-        MediatR.IRequestHandler<AddSongToCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public AddSongToCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public AddSongToCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            AddSongToCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-            return await validation.Apply(parameters => ApplyAddSongRequest(dbContext, parameters));
-        }
-
-        private async Task<Unit> ApplyAddSongRequest(TvContext dbContext, Parameters parameters)
-        {
-            parameters.Collection.MediaItems.Add(parameters.Song);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            AddSongToCollection request) =>
-            (await CollectionMustExist(dbContext, request), await ValidateSong(dbContext, request))
-            .Apply((collection, episode) => new Parameters(collection, episode));
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            AddSongToCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Task<Validation<BaseError, Song>> ValidateSong(
-            TvContext dbContext,
-            AddSongToCollection request) =>
-            dbContext.Songs
-                .SelectOneAsync(m => m.Id, e => e.Id == request.SongId)
-                .Map(o => o.ToValidation<BaseError>("Song does not exist"));
-
-        private record Parameters(Collection Collection, Song Song);
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        AddSongToCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, parameters => ApplyAddSongRequest(dbContext, parameters));
+    }
+
+    private async Task<Unit> ApplyAddSongRequest(TvContext dbContext, Parameters parameters)
+    {
+        parameters.Collection.MediaItems.Add(parameters.Song);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(parameters.Collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        AddSongToCollection request) =>
+        (await CollectionMustExist(dbContext, request), await ValidateSong(dbContext, request))
+        .Apply((collection, episode) => new Parameters(collection, episode));
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        AddSongToCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Task<Validation<BaseError, Song>> ValidateSong(
+        TvContext dbContext,
+        AddSongToCollection request) =>
+        dbContext.Songs
+            .SelectOneAsync(m => m.Id, e => e.Id == request.SongId)
+            .Map(o => o.ToValidation<BaseError>("Song does not exist"));
+
+    private record Parameters(Collection Collection, Song Song);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddTraktList.cs b/ErsatzTV.Application/MediaCollections/Commands/AddTraktList.cs
index 75657ea3d..9568409fe 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddTraktList.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddTraktList.cs
@@ -1,9 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record AddTraktList(string TraktListUrl) : IRequest<Either<BaseError, Unit>>, IBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record AddTraktList(string TraktListUrl) : IRequest<Either<BaseError, Unit>>, IBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs
index b89e801cf..dfdbef63b 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs
@@ -1,80 +1,74 @@
 using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class AddTraktListHandler : TraktCommandBase, IRequestHandler<AddTraktList, Either<BaseError, Unit>>
 {
-    public class AddTraktListHandler : TraktCommandBase, IRequestHandler<AddTraktList, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IEntityLocker _entityLocker;
+
+    public AddTraktListHandler(
+        ITraktApiClient traktApiClient,
+        ISearchRepository searchRepository,
+        ISearchIndex searchIndex,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILogger<AddTraktListHandler> logger,
+        IEntityLocker entityLocker)
+        : base(traktApiClient, searchRepository, searchIndex, logger)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IEntityLocker _entityLocker;
-
-        public AddTraktListHandler(
-            ITraktApiClient traktApiClient,
-            ISearchRepository searchRepository,
-            ISearchIndex searchIndex,
-            IDbContextFactory<TvContext> dbContextFactory,
-            ILogger<AddTraktListHandler> logger,
-            IEntityLocker entityLocker)
-            : base(traktApiClient, searchRepository, searchIndex, logger)
-        {
-            _dbContextFactory = dbContextFactory;
-            _entityLocker = entityLocker;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(AddTraktList request, CancellationToken cancellationToken)
-        {
-            try
-            {
-                Validation<BaseError, Parameters> validation = ValidateUrl(request);
-                return await validation.Match(
-                    DoAdd,
-                    error => Task.FromResult<Either<BaseError, Unit>>(error.Join()));
-            }
-            finally
-            {
-                _entityLocker.UnlockTrakt();
-            }
-        }
-        
-        private static Validation<BaseError, Parameters> ValidateUrl(AddTraktList request)
-        {
-            const string PATTERN = @"(?:https:\/\/trakt\.tv\/users\/)?([\w\-_]+)\/(?:lists\/)?([\w\-_]+)";
-            Match match = Regex.Match(request.TraktListUrl, PATTERN);
-            if (match.Success)
-            {
-                string user = match.Groups[1].Value;
-                string list = match.Groups[2].Value;
-                return new Parameters(user, list);
-            }
-
-            return BaseError.New("Invalid Trakt list url");
-        }
-
-        private async Task<Either<BaseError, Unit>> DoAdd(Parameters parameters)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            
-            return await TraktApiClient.GetUserList(parameters.User, parameters.List)
-                .BindT(list => SaveList(dbContext, list))
-                .BindT(list => SaveListItems(dbContext, list))
-                .BindT(list => MatchListItems(dbContext, list))
-                .MapT(_ => Unit.Default);
-            
-            // match list items (and update in search index)
-        }
-
-        private record Parameters(string User, string List);
+        _dbContextFactory = dbContextFactory;
+        _entityLocker = entityLocker;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(AddTraktList request, CancellationToken cancellationToken)
+    {
+        try
+        {
+            Validation<BaseError, Parameters> validation = ValidateUrl(request);
+            return await validation.Match(
+                DoAdd,
+                error => Task.FromResult<Either<BaseError, Unit>>(error.Join()));
+        }
+        finally
+        {
+            _entityLocker.UnlockTrakt();
+        }
+    }
+        
+    private static Validation<BaseError, Parameters> ValidateUrl(AddTraktList request)
+    {
+        const string PATTERN = @"(?:https:\/\/trakt\.tv\/users\/)?([\w\-_]+)\/(?:lists\/)?([\w\-_]+)";
+        Match match = Regex.Match(request.TraktListUrl, PATTERN);
+        if (match.Success)
+        {
+            string user = match.Groups[1].Value;
+            string list = match.Groups[2].Value;
+            return new Parameters(user, list);
+        }
+
+        return BaseError.New("Invalid Trakt list url");
+    }
+
+    private async Task<Either<BaseError, Unit>> DoAdd(Parameters parameters)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            
+        return await TraktApiClient.GetUserList(parameters.User, parameters.List)
+            .BindT(list => SaveList(dbContext, list))
+            .BindT(list => SaveListItems(dbContext, list))
+            .BindT(list => MatchListItems(dbContext, list))
+            .MapT(_ => Unit.Default);
+            
+        // match list items (and update in search index)
+    }
+
+    private record Parameters(string User, string List);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/CreateCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/CreateCollection.cs
index b4450b085..2fdbd8807 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateCollection.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record CreateCollection(string Name) : IRequest<Either<BaseError, MediaCollectionViewModel>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record CreateCollection(string Name) : IRequest<Either<BaseError, MediaCollectionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/CreateCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/CreateCollectionHandler.cs
index e64068714..6ec7d3070 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateCollectionHandler.cs
@@ -1,69 +1,62 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class CreateCollectionHandler :
+    IRequestHandler<CreateCollection, Either<BaseError, MediaCollectionViewModel>>
 {
-    public class CreateCollectionHandler :
-        IRequestHandler<CreateCollection, Either<BaseError, MediaCollectionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, MediaCollectionViewModel>> Handle(
+        CreateCollection request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreateCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, MediaCollectionViewModel>> Handle(
-            CreateCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => PersistCollection(dbContext, c));
-        }
-
-        private static async Task<MediaCollectionViewModel> PersistCollection(
-            TvContext dbContext,
-            Collection collection)
-        {
-            await dbContext.Collections.AddAsync(collection);
-            await dbContext.SaveChangesAsync();
-            return ProjectToViewModel(collection);
-        }
-
-        private static Task<Validation<BaseError, Collection>> Validate(
-            TvContext dbContext,
-            CreateCollection request) =>
-            ValidateName(dbContext, request).MapT(
-                name => new Collection
-                {
-                    Name = name,
-                    MediaItems = new List<MediaItem>()
-                });
-
-        private static async Task<Validation<BaseError, string>> ValidateName(
-            TvContext dbContext,
-            CreateCollection createCollection)
-        {
-            List<string> allNames = await dbContext.Collections
-                .Map(c => c.Name)
-                .ToListAsync();
-
-            Validation<BaseError, string> result1 = createCollection.NotEmpty(c => c.Name)
-                .Bind(_ => createCollection.NotLongerThan(50)(c => c.Name));
-
-            var result2 = Optional(createCollection.Name)
-                .Where(name => !allNames.Contains(name))
-                .ToValidation<BaseError>("Collection name must be unique");
-
-            return (result1, result2).Apply((_, _) => createCollection.Name);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Collection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => PersistCollection(dbContext, c));
     }
-}
+
+    private static async Task<MediaCollectionViewModel> PersistCollection(
+        TvContext dbContext,
+        Collection collection)
+    {
+        await dbContext.Collections.AddAsync(collection);
+        await dbContext.SaveChangesAsync();
+        return ProjectToViewModel(collection);
+    }
+
+    private static Task<Validation<BaseError, Collection>> Validate(
+        TvContext dbContext,
+        CreateCollection request) =>
+        ValidateName(dbContext, request).MapT(
+            name => new Collection
+            {
+                Name = name,
+                MediaItems = new List<MediaItem>()
+            });
+
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        CreateCollection createCollection)
+    {
+        List<string> allNames = await dbContext.Collections
+            .Map(c => c.Name)
+            .ToListAsync();
+
+        Validation<BaseError, string> result1 = createCollection.NotEmpty(c => c.Name)
+            .Bind(_ => createCollection.NotLongerThan(50)(c => c.Name));
+
+        var result2 = Optional(createCollection.Name)
+            .Where(name => !allNames.Contains(name))
+            .ToValidation<BaseError>("Collection name must be unique");
+
+        return (result1, result2).Apply((_, _) => createCollection.Name);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollection.cs
index b1cba7947..aa094dcff 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollection.cs
@@ -1,13 +1,9 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record CreateMultiCollectionItem(int? CollectionId, int? SmartCollectionId, bool ScheduleAsGroup, PlaybackOrder PlaybackOrder);
+namespace ErsatzTV.Application.MediaCollections;
 
-    public record CreateMultiCollection
-        (string Name, List<CreateMultiCollectionItem> Items) : IRequest<Either<BaseError, MultiCollectionViewModel>>;
-}
+public record CreateMultiCollectionItem(int? CollectionId, int? SmartCollectionId, bool ScheduleAsGroup, PlaybackOrder PlaybackOrder);
+
+public record CreateMultiCollection
+    (string Name, List<CreateMultiCollectionItem> Items) : IRequest<Either<BaseError, MultiCollectionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs
index 4b8a8c81f..054c381b3 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs
@@ -1,113 +1,105 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class CreateMultiCollectionHandler :
+    IRequestHandler<CreateMultiCollection, Either<BaseError, MultiCollectionViewModel>>
 {
-    public class CreateMultiCollectionHandler :
-        IRequestHandler<CreateMultiCollection, Either<BaseError, MultiCollectionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateMultiCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, MultiCollectionViewModel>> Handle(
+        CreateMultiCollection request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreateMultiCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, MultiCollectionViewModel>> Handle(
-            CreateMultiCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, MultiCollection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => PersistCollection(dbContext, c));
-        }
-
-        private static async Task<MultiCollectionViewModel> PersistCollection(
-            TvContext dbContext,
-            MultiCollection multiCollection)
-        {
-            await dbContext.MultiCollections.AddAsync(multiCollection);
-            await dbContext.SaveChangesAsync();
-            await dbContext.Entry(multiCollection)
-                .Collection(c => c.MultiCollectionItems)
-                .Query()
-                .Include(i => i.Collection)
-                .LoadAsync();
-            await dbContext.Entry(multiCollection)
-                .Collection(c => c.MultiCollectionSmartItems)
-                .Query()
-                .Include(i => i.SmartCollection)
-                .LoadAsync();
-            return ProjectToViewModel(multiCollection);
-        }
-
-        private static Task<Validation<BaseError, MultiCollection>> Validate(
-            TvContext dbContext,
-            CreateMultiCollection request) =>
-            ValidateName(dbContext, request).MapT(
-                name => new MultiCollection
-                {
-                    Name = name,
-                    MultiCollectionItems = request.Items.Bind(
-                            i =>
-                            {
-                                if (i.CollectionId.HasValue)
-                                {
-                                    return Some(
-                                        new MultiCollectionItem
-                                        {
-                                            CollectionId = i.CollectionId.Value,
-                                            ScheduleAsGroup = i.ScheduleAsGroup,
-                                            PlaybackOrder = i.PlaybackOrder
-                                        });
-                                }
-
-                                return Option<MultiCollectionItem>.None;
-                            })
-                        .ToList(),
-                    MultiCollectionSmartItems = request.Items.Bind(
-                            i =>
-                            {
-                                if (i.SmartCollectionId.HasValue)
-                                {
-                                    return Some(
-                                        new MultiCollectionSmartItem
-                                        {
-                                            SmartCollectionId = i.SmartCollectionId.Value,
-                                            ScheduleAsGroup = i.ScheduleAsGroup,
-                                            PlaybackOrder = i.PlaybackOrder
-                                        });
-                                }
-
-                                return Option<MultiCollectionSmartItem>.None;
-                            })
-                        .ToList()
-                });
-
-        private static async Task<Validation<BaseError, string>> ValidateName(
-            TvContext dbContext,
-            CreateMultiCollection createMultiCollection)
-        {
-            List<string> allNames = await dbContext.MultiCollections
-                .Map(c => c.Name)
-                .ToListAsync();
-
-            Validation<BaseError, string> result1 = createMultiCollection.NotEmpty(c => c.Name)
-                .Bind(_ => createMultiCollection.NotLongerThan(50)(c => c.Name));
-
-            var result2 = Optional(createMultiCollection.Name)
-                .Where(name => !allNames.Contains(name))
-                .ToValidation<BaseError>("MultiCollection name must be unique");
-
-            return (result1, result2).Apply((_, _) => createMultiCollection.Name);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, MultiCollection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => PersistCollection(dbContext, c));
     }
-}
+
+    private static async Task<MultiCollectionViewModel> PersistCollection(
+        TvContext dbContext,
+        MultiCollection multiCollection)
+    {
+        await dbContext.MultiCollections.AddAsync(multiCollection);
+        await dbContext.SaveChangesAsync();
+        await dbContext.Entry(multiCollection)
+            .Collection(c => c.MultiCollectionItems)
+            .Query()
+            .Include(i => i.Collection)
+            .LoadAsync();
+        await dbContext.Entry(multiCollection)
+            .Collection(c => c.MultiCollectionSmartItems)
+            .Query()
+            .Include(i => i.SmartCollection)
+            .LoadAsync();
+        return ProjectToViewModel(multiCollection);
+    }
+
+    private static Task<Validation<BaseError, MultiCollection>> Validate(
+        TvContext dbContext,
+        CreateMultiCollection request) =>
+        ValidateName(dbContext, request).MapT(
+            name => new MultiCollection
+            {
+                Name = name,
+                MultiCollectionItems = request.Items.Bind(
+                        i =>
+                        {
+                            if (i.CollectionId.HasValue)
+                            {
+                                return Some(
+                                    new MultiCollectionItem
+                                    {
+                                        CollectionId = i.CollectionId.Value,
+                                        ScheduleAsGroup = i.ScheduleAsGroup,
+                                        PlaybackOrder = i.PlaybackOrder
+                                    });
+                            }
+
+                            return Option<MultiCollectionItem>.None;
+                        })
+                    .ToList(),
+                MultiCollectionSmartItems = request.Items.Bind(
+                        i =>
+                        {
+                            if (i.SmartCollectionId.HasValue)
+                            {
+                                return Some(
+                                    new MultiCollectionSmartItem
+                                    {
+                                        SmartCollectionId = i.SmartCollectionId.Value,
+                                        ScheduleAsGroup = i.ScheduleAsGroup,
+                                        PlaybackOrder = i.PlaybackOrder
+                                    });
+                            }
+
+                            return Option<MultiCollectionSmartItem>.None;
+                        })
+                    .ToList()
+            });
+
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        CreateMultiCollection createMultiCollection)
+    {
+        List<string> allNames = await dbContext.MultiCollections
+            .Map(c => c.Name)
+            .ToListAsync();
+
+        Validation<BaseError, string> result1 = createMultiCollection.NotEmpty(c => c.Name)
+            .Bind(_ => createMultiCollection.NotLongerThan(50)(c => c.Name));
+
+        var result2 = Optional(createMultiCollection.Name)
+            .Where(name => !allNames.Contains(name))
+            .ToValidation<BaseError>("MultiCollection name must be unique");
+
+        return (result1, result2).Apply((_, _) => createMultiCollection.Name);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollection.cs
index 9ef5d956b..2a4977bcf 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollection.cs
@@ -1,9 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record CreateSmartCollection
-        (string Query, string Name) : IRequest<Either<BaseError, SmartCollectionViewModel>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record CreateSmartCollection
+    (string Query, string Name) : IRequest<Either<BaseError, SmartCollectionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollectionHandler.cs
index 5177d6e69..255bc5e65 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollectionHandler.cs
@@ -1,70 +1,62 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class CreateSmartCollectionHandler :
+    IRequestHandler<CreateSmartCollection, Either<BaseError, SmartCollectionViewModel>>
 {
-    public class CreateSmartCollectionHandler :
-        IRequestHandler<CreateSmartCollection, Either<BaseError, SmartCollectionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateSmartCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, SmartCollectionViewModel>> Handle(
+        CreateSmartCollection request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreateSmartCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, SmartCollectionViewModel>> Handle(
-            CreateSmartCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => PersistCollection(dbContext, c));
-        }
-
-        private static async Task<SmartCollectionViewModel> PersistCollection(
-            TvContext dbContext,
-            SmartCollection smartCollection)
-        {
-            await dbContext.SmartCollections.AddAsync(smartCollection);
-            await dbContext.SaveChangesAsync();
-            return ProjectToViewModel(smartCollection);
-        }
-
-        private static Task<Validation<BaseError, SmartCollection>> Validate(
-            TvContext dbContext,
-            CreateSmartCollection request) =>
-            ValidateName(dbContext, request).MapT(
-                name => new SmartCollection
-                {
-                    Name = name,
-                    Query = request.Query
-                });
-
-        private static async Task<Validation<BaseError, string>> ValidateName(
-            TvContext dbContext,
-            CreateSmartCollection createSmartCollection)
-        {
-            List<string> allNames = await dbContext.SmartCollections
-                .Map(c => c.Name)
-                .ToListAsync();
-
-            Validation<BaseError, string> result1 = createSmartCollection.NotEmpty(c => c.Name)
-                .Bind(_ => createSmartCollection.NotLongerThan(50)(c => c.Name));
-
-            var result2 = Optional(createSmartCollection.Name)
-                .Where(name => !allNames.Contains(name))
-                .ToValidation<BaseError>("SmartCollection name must be unique");
-
-            return (result1, result2).Apply((_, _) => createSmartCollection.Name);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => PersistCollection(dbContext, c));
     }
-}
+
+    private static async Task<SmartCollectionViewModel> PersistCollection(
+        TvContext dbContext,
+        SmartCollection smartCollection)
+    {
+        await dbContext.SmartCollections.AddAsync(smartCollection);
+        await dbContext.SaveChangesAsync();
+        return ProjectToViewModel(smartCollection);
+    }
+
+    private static Task<Validation<BaseError, SmartCollection>> Validate(
+        TvContext dbContext,
+        CreateSmartCollection request) =>
+        ValidateName(dbContext, request).MapT(
+            name => new SmartCollection
+            {
+                Name = name,
+                Query = request.Query
+            });
+
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        CreateSmartCollection createSmartCollection)
+    {
+        List<string> allNames = await dbContext.SmartCollections
+            .Map(c => c.Name)
+            .ToListAsync();
+
+        Validation<BaseError, string> result1 = createSmartCollection.NotEmpty(c => c.Name)
+            .Bind(_ => createSmartCollection.NotLongerThan(50)(c => c.Name));
+
+        var result2 = Optional(createSmartCollection.Name)
+            .Where(name => !allNames.Contains(name))
+            .ToValidation<BaseError>("SmartCollection name must be unique");
+
+        return (result1, result2).Apply((_, _) => createSmartCollection.Name);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/DeleteCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/DeleteCollection.cs
index fb0b8f3c1..55ddc1ab4 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteCollection.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record DeleteCollection(int CollectionId) : IRequest<Either<BaseError, LanguageExt.Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record DeleteCollection(int CollectionId) : IRequest<Either<BaseError, LanguageExt.Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/DeleteCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/DeleteCollectionHandler.cs
index 00f53d3aa..530fd0746 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteCollectionHandler.cs
@@ -1,42 +1,38 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class DeleteCollectionHandler : MediatR.IRequestHandler<DeleteCollection, Either<BaseError, Unit>>
 {
-    public class DeleteCollectionHandler : MediatR.IRequestHandler<DeleteCollection, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeleteCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteCollection request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-        public DeleteCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Validation<BaseError, Collection> validation = await CollectionMustExist(dbContext, request);
-            return await validation.Apply(c => DoDeletion(dbContext, c));
-        }
-
-        private static Task<Unit> DoDeletion(TvContext dbContext, Collection collection)
-        {
-            dbContext.Collections.Remove(collection);
-            return dbContext.SaveChangesAsync().ToUnit();
-        }
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            DeleteCollection request) =>
-            dbContext.Collections
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>($"Collection {request.CollectionId} does not exist."));
+        Validation<BaseError, Collection> validation = await CollectionMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => DoDeletion(dbContext, c));
     }
-}
+
+    private static Task<Unit> DoDeletion(TvContext dbContext, Collection collection)
+    {
+        dbContext.Collections.Remove(collection);
+        return dbContext.SaveChangesAsync().ToUnit();
+    }
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        DeleteCollection request) =>
+        dbContext.Collections
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>($"Collection {request.CollectionId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollection.cs
index 52e4f098d..886da8b45 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollection.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record DeleteMultiCollection(int MultiCollectionId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record DeleteMultiCollection(int MultiCollectionId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollectionHandler.cs
index 14b1d2fe7..5f37670a7 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteMultiCollectionHandler.cs
@@ -1,42 +1,38 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class DeleteMultiCollectionHandler : MediatR.IRequestHandler<DeleteMultiCollection, Either<BaseError, Unit>>
 {
-    public class DeleteMultiCollectionHandler : MediatR.IRequestHandler<DeleteMultiCollection, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeleteMultiCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteMultiCollection request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-        public DeleteMultiCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteMultiCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Validation<BaseError, MultiCollection> validation = await MultiCollectionMustExist(dbContext, request);
-            return await validation.Apply(c => DoDeletion(dbContext, c));
-        }
-
-        private static Task<Unit> DoDeletion(TvContext dbContext, MultiCollection multiCollection)
-        {
-            dbContext.MultiCollections.Remove(multiCollection);
-            return dbContext.SaveChangesAsync().ToUnit();
-        }
-
-        private static Task<Validation<BaseError, MultiCollection>> MultiCollectionMustExist(
-            TvContext dbContext,
-            DeleteMultiCollection request) =>
-            dbContext.MultiCollections
-                .SelectOneAsync(c => c.Id, c => c.Id == request.MultiCollectionId)
-                .Map(o => o.ToValidation<BaseError>($"MultiCollection {request.MultiCollectionId} does not exist."));
+        Validation<BaseError, MultiCollection> validation = await MultiCollectionMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => DoDeletion(dbContext, c));
     }
-}
+
+    private static Task<Unit> DoDeletion(TvContext dbContext, MultiCollection multiCollection)
+    {
+        dbContext.MultiCollections.Remove(multiCollection);
+        return dbContext.SaveChangesAsync().ToUnit();
+    }
+
+    private static Task<Validation<BaseError, MultiCollection>> MultiCollectionMustExist(
+        TvContext dbContext,
+        DeleteMultiCollection request) =>
+        dbContext.MultiCollections
+            .SelectOneAsync(c => c.Id, c => c.Id == request.MultiCollectionId)
+            .Map(o => o.ToValidation<BaseError>($"MultiCollection {request.MultiCollectionId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollection.cs
index 7fe1c6ffb..02d9e3277 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollection.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record DeleteSmartCollection(int SmartCollectionId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record DeleteSmartCollection(int SmartCollectionId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollectionHandler.cs
index 7036237ff..216517728 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteSmartCollectionHandler.cs
@@ -1,42 +1,38 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class DeleteSmartCollectionHandler : MediatR.IRequestHandler<DeleteSmartCollection, Either<BaseError, Unit>>
 {
-    public class DeleteSmartCollectionHandler : MediatR.IRequestHandler<DeleteSmartCollection, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeleteSmartCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteSmartCollection request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-        public DeleteSmartCollectionHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteSmartCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Validation<BaseError, SmartCollection> validation = await SmartCollectionMustExist(dbContext, request);
-            return await validation.Apply(c => DoDeletion(dbContext, c));
-        }
-
-        private static Task<Unit> DoDeletion(TvContext dbContext, SmartCollection smartCollection)
-        {
-            dbContext.SmartCollections.Remove(smartCollection);
-            return dbContext.SaveChangesAsync().ToUnit();
-        }
-
-        private static Task<Validation<BaseError, SmartCollection>> SmartCollectionMustExist(
-            TvContext dbContext,
-            DeleteSmartCollection request) =>
-            dbContext.SmartCollections
-                .SelectOneAsync(c => c.Id, c => c.Id == request.SmartCollectionId)
-                .Map(o => o.ToValidation<BaseError>($"SmartCollection {request.SmartCollectionId} does not exist."));
+        Validation<BaseError, SmartCollection> validation = await SmartCollectionMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => DoDeletion(dbContext, c));
     }
-}
+
+    private static Task<Unit> DoDeletion(TvContext dbContext, SmartCollection smartCollection)
+    {
+        dbContext.SmartCollections.Remove(smartCollection);
+        return dbContext.SaveChangesAsync().ToUnit();
+    }
+
+    private static Task<Validation<BaseError, SmartCollection>> SmartCollectionMustExist(
+        TvContext dbContext,
+        DeleteSmartCollection request) =>
+        dbContext.SmartCollections
+            .SelectOneAsync(c => c.Id, c => c.Id == request.SmartCollectionId)
+            .Map(o => o.ToValidation<BaseError>($"SmartCollection {request.SmartCollectionId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktList.cs b/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktList.cs
index 94724e92c..47f38ec81 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktList.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktList.cs
@@ -1,9 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record DeleteTraktList(int TraktListId) : IRequest<Either<BaseError, LanguageExt.Unit>>,
-        IBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record DeleteTraktList(int TraktListId) : IRequest<Either<BaseError, LanguageExt.Unit>>,
+    IBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs
index 5fa7b99db..4f66001e2 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs
@@ -1,79 +1,72 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
-using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class DeleteTraktListHandler : TraktCommandBase, MediatR.IRequestHandler<DeleteTraktList, Either<BaseError, Unit>>
 {
-    public class DeleteTraktListHandler : TraktCommandBase, MediatR.IRequestHandler<DeleteTraktList, Either<BaseError, Unit>>
+    private readonly ISearchRepository _searchRepository;
+    private readonly ISearchIndex _searchIndex;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IEntityLocker _entityLocker;
+
+    public DeleteTraktListHandler(
+        ITraktApiClient traktApiClient,
+        ISearchRepository searchRepository,
+        ISearchIndex searchIndex,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILogger<DeleteTraktListHandler> logger,
+        IEntityLocker entityLocker)
+        : base(traktApiClient, searchRepository, searchIndex, logger)
     {
-        private readonly ISearchRepository _searchRepository;
-        private readonly ISearchIndex _searchIndex;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IEntityLocker _entityLocker;
+        _searchRepository = searchRepository;
+        _searchIndex = searchIndex;
+        _dbContextFactory = dbContextFactory;
+        _entityLocker = entityLocker;
+    }
 
-        public DeleteTraktListHandler(
-            ITraktApiClient traktApiClient,
-            ISearchRepository searchRepository,
-            ISearchIndex searchIndex,
-            IDbContextFactory<TvContext> dbContextFactory,
-            ILogger<DeleteTraktListHandler> logger,
-            IEntityLocker entityLocker)
-            : base(traktApiClient, searchRepository, searchIndex, logger)
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteTraktList request,
+        CancellationToken cancellationToken)
+    {
+        try
         {
-            _searchRepository = searchRepository;
-            _searchIndex = searchIndex;
-            _dbContextFactory = dbContextFactory;
-            _entityLocker = entityLocker;
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+            Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
+            return await LanguageExtensions.Apply(validation, c => DoDeletion(dbContext, c));
         }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteTraktList request,
-            CancellationToken cancellationToken)
+        finally
         {
-            try
-            {
-                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-                Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
-                return await validation.Apply(c => DoDeletion(dbContext, c));
-            }
-            finally
-            {
-                _entityLocker.UnlockTrakt();
-            }
-        }
-
-        private async Task<Unit> DoDeletion(TvContext dbContext, TraktList traktList)
-        {
-            var mediaItemIds = traktList.Items.Bind(i => Optional(i.MediaItemId)).ToList();
-
-            dbContext.TraktLists.Remove(traktList);
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                foreach (int mediaItemId in mediaItemIds)
-                {
-                    foreach (MediaItem mediaItem in await _searchRepository.GetItemToIndex(mediaItemId))
-                    {
-                        await _searchIndex.UpdateItems(_searchRepository, new[] { mediaItem }.ToList());
-                    }
-                }
-            }
-
-            _searchIndex.Commit();
-
-            return Unit.Default;
+            _entityLocker.UnlockTrakt();
         }
     }
-}
+
+    private async Task<Unit> DoDeletion(TvContext dbContext, TraktList traktList)
+    {
+        var mediaItemIds = traktList.Items.Bind(i => Optional(i.MediaItemId)).ToList();
+
+        dbContext.TraktLists.Remove(traktList);
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            foreach (int mediaItemId in mediaItemIds)
+            {
+                foreach (MediaItem mediaItem in await _searchRepository.GetItemToIndex(mediaItemId))
+                {
+                    await _searchIndex.UpdateItems(_searchRepository, new[] { mediaItem }.ToList());
+                }
+            }
+        }
+
+        _searchIndex.Commit();
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItems.cs b/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItems.cs
index 34c06c913..e651129b4 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItems.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItems.cs
@@ -1,10 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record MatchTraktListItems(int TraktListId, bool Unlock = true) : IRequest<Either<BaseError, Unit>>,
-        IBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record MatchTraktListItems(int TraktListId, bool Unlock = true) : IRequest<Either<BaseError, Unit>>,
+    IBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs
index d9251e202..cb0fb2d32 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs
@@ -1,58 +1,52 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class MatchTraktListItemsHandler : TraktCommandBase,
+    IRequestHandler<MatchTraktListItems, Either<BaseError, Unit>>
 {
-    public class MatchTraktListItemsHandler : TraktCommandBase,
-        IRequestHandler<MatchTraktListItems, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IEntityLocker _entityLocker;
+
+    public MatchTraktListItemsHandler(
+        ITraktApiClient traktApiClient,
+        ISearchRepository searchRepository,
+        ISearchIndex searchIndex,
+        IDbContextFactory<TvContext> dbContextFactory,
+        ILogger<MatchTraktListItemsHandler> logger,
+        IEntityLocker entityLocker) : base(traktApiClient, searchRepository, searchIndex, logger)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IEntityLocker _entityLocker;
+        _dbContextFactory = dbContextFactory;
+        _entityLocker = entityLocker;
+    }
 
-        public MatchTraktListItemsHandler(
-            ITraktApiClient traktApiClient,
-            ISearchRepository searchRepository,
-            ISearchIndex searchIndex,
-            IDbContextFactory<TvContext> dbContextFactory,
-            ILogger<MatchTraktListItemsHandler> logger,
-            IEntityLocker entityLocker) : base(traktApiClient, searchRepository, searchIndex, logger)
+    public async Task<Either<BaseError, Unit>> Handle(
+        MatchTraktListItems request,
+        CancellationToken cancellationToken)
+    {
+        try
         {
-            _dbContextFactory = dbContextFactory;
-            _entityLocker = entityLocker;
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
+            return await validation.Match(
+                async l => await MatchListItems(dbContext, l).MapT(_ => Unit.Default),
+                error => Task.FromResult<Either<BaseError, Unit>>(error.Join()));
         }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            MatchTraktListItems request,
-            CancellationToken cancellationToken)
+        finally
         {
-            try
+            if (request.Unlock)
             {
-                await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-                Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
-                return await validation.Match(
-                    async l => await MatchListItems(dbContext, l).MapT(_ => Unit.Default),
-                    error => Task.FromResult<Either<BaseError, Unit>>(error.Join()));
-            }
-            finally
-            {
-                if (request.Unlock)
-                {
-                    _entityLocker.UnlockTrakt();
-                }
+                _entityLocker.UnlockTrakt();
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollection.cs
index 29aaa6703..1f949b695 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollection.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public record RemoveItemsFromCollection(int MediaCollectionId) : MediatR.IRequest<Either<BaseError, Unit>>
 {
-    public record RemoveItemsFromCollection(int MediaCollectionId) : MediatR.IRequest<Either<BaseError, Unit>>
-    {
-        public List<int> MediaItemIds { get; set; } = new();
-    }
-}
+    public List<int> MediaItemIds { get; set; } = new();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollectionHandler.cs
index 4e932a0f6..2c4537755 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/RemoveItemsFromCollectionHandler.cs
@@ -1,78 +1,73 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class RemoveItemsFromCollectionHandler :
+    MediatR.IRequestHandler<RemoveItemsFromCollection, Either<BaseError, Unit>>
 {
-    public class RemoveItemsFromCollectionHandler :
-        MediatR.IRequestHandler<RemoveItemsFromCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public RemoveItemsFromCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public RemoveItemsFromCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            RemoveItemsFromCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyRemoveItemsRequest(dbContext, request, c));
-        }
-
-        private async Task<Unit> ApplyRemoveItemsRequest(
-            TvContext dbContext,
-            RemoveItemsFromCollection request,
-            Collection collection)
-        {
-            var itemsToRemove = collection.MediaItems
-                .Filter(m => request.MediaItemIds.Contains(m.Id))
-                .ToList();
-
-            itemsToRemove.ForEach(m => collection.MediaItems.Remove(m));
-
-            if (itemsToRemove.Any() && await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(collection.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, Collection>> Validate(
-            TvContext dbContext,
-            RemoveItemsFromCollection request) =>
-            CollectionMustExist(dbContext, request);
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            RemoveItemsFromCollection request) =>
-            dbContext.Collections
-                .Include(c => c.MediaItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.MediaCollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        RemoveItemsFromCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Collection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => ApplyRemoveItemsRequest(dbContext, request, c));
+    }
+
+    private async Task<Unit> ApplyRemoveItemsRequest(
+        TvContext dbContext,
+        RemoveItemsFromCollection request,
+        Collection collection)
+    {
+        var itemsToRemove = collection.MediaItems
+            .Filter(m => request.MediaItemIds.Contains(m.Id))
+            .ToList();
+
+        itemsToRemove.ForEach(m => collection.MediaItems.Remove(m));
+
+        if (itemsToRemove.Any() && await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(collection.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, Collection>> Validate(
+        TvContext dbContext,
+        RemoveItemsFromCollection request) =>
+        CollectionMustExist(dbContext, request);
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        RemoveItemsFromCollection request) =>
+        dbContext.Collections
+            .Include(c => c.MediaItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.MediaCollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs b/ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs
index 85f263a51..e535851e3 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs
@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
@@ -10,340 +6,337 @@ using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Core.Trakt;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public abstract class TraktCommandBase
 {
-    public abstract class TraktCommandBase
+    private readonly ISearchRepository _searchRepository;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ILogger _logger;
+
+    protected TraktCommandBase(
+        ITraktApiClient traktApiClient,
+        ISearchRepository searchRepository,
+        ISearchIndex searchIndex,
+        ILogger logger)
     {
-        private readonly ISearchRepository _searchRepository;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ILogger _logger;
+        _searchRepository = searchRepository;
+        _searchIndex = searchIndex;
+        _logger = logger;
+        TraktApiClient = traktApiClient;
+    }
 
-        protected TraktCommandBase(
-            ITraktApiClient traktApiClient,
-            ISearchRepository searchRepository,
-            ISearchIndex searchIndex,
-            ILogger logger)
-        {
-            _searchRepository = searchRepository;
-            _searchIndex = searchIndex;
-            _logger = logger;
-            TraktApiClient = traktApiClient;
-        }
+    protected ITraktApiClient TraktApiClient { get; }
 
-        protected ITraktApiClient TraktApiClient { get; }
+    protected static Task<Validation<BaseError, TraktList>>
+        TraktListMustExist(TvContext dbContext, int traktListId) =>
+        dbContext.TraktLists
+            .Include(l => l.Items)
+            .ThenInclude(i => i.Guids)
+            .SelectOneAsync(c => c.Id, c => c.Id == traktListId)
+            .Map(o => o.ToValidation<BaseError>($"TraktList {traktListId} does not exist."));
 
-        protected static Task<Validation<BaseError, TraktList>>
-            TraktListMustExist(TvContext dbContext, int traktListId) =>
-            dbContext.TraktLists
-                .Include(l => l.Items)
-                .ThenInclude(i => i.Guids)
-                .SelectOneAsync(c => c.Id, c => c.Id == traktListId)
-                .Map(o => o.ToValidation<BaseError>($"TraktList {traktListId} does not exist."));
+    protected async Task<Either<BaseError, TraktList>> SaveList(TvContext dbContext, TraktList list)
+    {
+        Option<TraktList> maybeExisting = await dbContext.TraktLists
+            .Include(l => l.Items)
+            .ThenInclude(i => i.Guids)
+            .SelectOneAsync(tl => tl.Id, tl => tl.User == list.User && tl.List == list.List);
 
-        protected async Task<Either<BaseError, TraktList>> SaveList(TvContext dbContext, TraktList list)
-        {
-            Option<TraktList> maybeExisting = await dbContext.TraktLists
-                .Include(l => l.Items)
-                .ThenInclude(i => i.Guids)
-                .SelectOneAsync(tl => tl.Id, tl => tl.User == list.User && tl.List == list.List);
-
-            return await maybeExisting.Match(
-                async existing =>
-                {
-                    existing.Name = list.Name;
-                    existing.Description = list.Description;
-                    existing.ItemCount = list.ItemCount;
-
-                    await dbContext.SaveChangesAsync();
-
-                    return existing;
-                },
-                async () =>
-                {
-                    await dbContext.TraktLists.AddAsync(list);
-                    await dbContext.SaveChangesAsync();
-
-                    return list;
-                });
-        }
-
-        protected async Task<Either<BaseError, TraktList>> SaveListItems(TvContext dbContext, TraktList list)
-        {
-            Either<BaseError, List<TraktListItemWithGuids>> maybeItems =
-                await TraktApiClient.GetUserListItems(list.User, list.List);
-
-            return await maybeItems.Match<Task<Either<BaseError, TraktList>>>(
-                async items =>
-                {
-                    var toAdd = items.Filter(i => list.Items.All(i2 => i2.TraktId != i.TraktId)).ToList();
-                    var toRemove = list.Items.Filter(i => items.All(i2 => i2.TraktId != i.TraktId)).ToList();
-                    var toUpdate = list.Items.Filter(i => !toRemove.Contains(i)).ToList();
-                    
-                    list.Items.RemoveAll(toRemove.Contains);
-                    list.Items.AddRange(toAdd.Map(a => ProjectItem(list, a)));
-
-                    foreach (TraktListItem existing in toUpdate)
-                    {
-                        Option<TraktListItem> maybeIncoming = list.Items.Find(i => i.TraktId == existing.TraktId);
-                        foreach (TraktListItem incoming in maybeIncoming)
-                        {
-                            existing.Kind = incoming.Kind;
-                            existing.Rank = incoming.Rank;
-                            existing.Title = incoming.Title;
-                            existing.Year = incoming.Year;
-                            existing.Season = incoming.Season;
-                            existing.Episode = incoming.Episode;
-                            existing.Guids.Clear();
-                            existing.Guids.AddRange(incoming.Guids);
-                            existing.MediaItemId = null;
-                            existing.MediaItem = null;
-                        }
-                    }
-
-                    await dbContext.SaveChangesAsync();
-
-                    return list;
-                },
-                error => Task.FromResult(Left<BaseError, TraktList>(error)));
-        }
-
-        protected async Task<Either<BaseError, TraktList>> MatchListItems(TvContext dbContext, TraktList list)
-        {
-            try
+        return await maybeExisting.Match(
+            async existing =>
             {
-                var ids = new System.Collections.Generic.HashSet<int>();
+                existing.Name = list.Name;
+                existing.Description = list.Description;
+                existing.ItemCount = list.ItemCount;
 
-                foreach (TraktListItem item in list.Items
-                    .OrderBy(i => i.Title).ThenBy(i => i.Year).ThenBy(i => i.Season).ThenBy(i => i.Episode))
+                await dbContext.SaveChangesAsync();
+
+                return existing;
+            },
+            async () =>
+            {
+                await dbContext.TraktLists.AddAsync(list);
+                await dbContext.SaveChangesAsync();
+
+                return list;
+            });
+    }
+
+    protected async Task<Either<BaseError, TraktList>> SaveListItems(TvContext dbContext, TraktList list)
+    {
+        Either<BaseError, List<TraktListItemWithGuids>> maybeItems =
+            await TraktApiClient.GetUserListItems(list.User, list.List);
+
+        return await maybeItems.Match<Task<Either<BaseError, TraktList>>>(
+            async items =>
+            {
+                var toAdd = items.Filter(i => list.Items.All(i2 => i2.TraktId != i.TraktId)).ToList();
+                var toRemove = list.Items.Filter(i => items.All(i2 => i2.TraktId != i.TraktId)).ToList();
+                var toUpdate = list.Items.Filter(i => !toRemove.Contains(i)).ToList();
+                    
+                list.Items.RemoveAll(toRemove.Contains);
+                list.Items.AddRange(toAdd.Map(a => ProjectItem(list, a)));
+
+                foreach (TraktListItem existing in toUpdate)
                 {
-                    switch (item.Kind)
+                    Option<TraktListItem> maybeIncoming = list.Items.Find(i => i.TraktId == existing.TraktId);
+                    foreach (TraktListItem incoming in maybeIncoming)
                     {
-                        case TraktListItemKind.Movie:
-                            Option<int> maybeMovieId = await IdentifyMovie(dbContext, item);
-                            foreach (int movieId in maybeMovieId)
-                            {
-                                ids.Add(movieId);
-                                item.MediaItemId = movieId;
-                            }
-
-                            break;
-                        case TraktListItemKind.Show:
-                            Option<int> maybeShowId = await IdentifyShow(dbContext, item);
-                            foreach (int showId in maybeShowId)
-                            {
-                                ids.Add(showId);
-                                item.MediaItemId = showId;
-                            }
-
-                            break;
-                        case TraktListItemKind.Season:
-                            Option<int> maybeSeasonId = await IdentifySeason(dbContext, item);
-                            foreach (int seasonId in maybeSeasonId)
-                            {
-                                ids.Add(seasonId);
-                                item.MediaItemId = seasonId;
-                            }
-
-                            break;
-                        default:
-                            Option<int> maybeEpisodeId = await IdentifyEpisode(dbContext, item);
-                            foreach (int episodeId in maybeEpisodeId)
-                            {
-                                ids.Add(episodeId);
-                                item.MediaItemId = episodeId;
-                            }
-
-                            break;
+                        existing.Kind = incoming.Kind;
+                        existing.Rank = incoming.Rank;
+                        existing.Title = incoming.Title;
+                        existing.Year = incoming.Year;
+                        existing.Season = incoming.Season;
+                        existing.Episode = incoming.Episode;
+                        existing.Guids.Clear();
+                        existing.Guids.AddRange(incoming.Guids);
+                        existing.MediaItemId = null;
+                        existing.MediaItem = null;
                     }
                 }
 
                 await dbContext.SaveChangesAsync();
 
-                foreach (int mediaItemId in ids)
-                {
-                    Option<MediaItem> maybeItem = await _searchRepository.GetItemToIndex(mediaItemId);
-                    foreach (MediaItem item in maybeItem)
-                    {
-                        await _searchIndex.UpdateItems(_searchRepository, new[] { item }.ToList());
-                    }
-                }
-
-                _searchIndex.Commit();
-
                 return list;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error matching trakt list items");
-                return BaseError.New(ex.Message);
-            }
-        }
+            },
+            error => Task.FromResult(Left<BaseError, TraktList>(error)));
+    }
 
-        private static TraktListItem ProjectItem(TraktList list, TraktListItemWithGuids item)
+    protected async Task<Either<BaseError, TraktList>> MatchListItems(TvContext dbContext, TraktList list)
+    {
+        try
         {
-            var result = new TraktListItem
+            var ids = new System.Collections.Generic.HashSet<int>();
+
+            foreach (TraktListItem item in list.Items
+                         .OrderBy(i => i.Title).ThenBy(i => i.Year).ThenBy(i => i.Season).ThenBy(i => i.Episode))
             {
-                TraktList = list,
-                Kind = item.Kind,
-                TraktId = item.TraktId,
-                Rank = item.Rank,
-                Title = item.Title,
-                Year = item.Year,
-                Season = item.Season,
-                Episode = item.Episode,
-            };
+                switch (item.Kind)
+                {
+                    case TraktListItemKind.Movie:
+                        Option<int> maybeMovieId = await IdentifyMovie(dbContext, item);
+                        foreach (int movieId in maybeMovieId)
+                        {
+                            ids.Add(movieId);
+                            item.MediaItemId = movieId;
+                        }
 
-            result.Guids = item.Guids.Map(g => new TraktListItemGuid { Guid = g, TraktListItem = result }).ToList();
+                        break;
+                    case TraktListItemKind.Show:
+                        Option<int> maybeShowId = await IdentifyShow(dbContext, item);
+                        foreach (int showId in maybeShowId)
+                        {
+                            ids.Add(showId);
+                            item.MediaItemId = showId;
+                        }
 
-            return result;
+                        break;
+                    case TraktListItemKind.Season:
+                        Option<int> maybeSeasonId = await IdentifySeason(dbContext, item);
+                        foreach (int seasonId in maybeSeasonId)
+                        {
+                            ids.Add(seasonId);
+                            item.MediaItemId = seasonId;
+                        }
+
+                        break;
+                    default:
+                        Option<int> maybeEpisodeId = await IdentifyEpisode(dbContext, item);
+                        foreach (int episodeId in maybeEpisodeId)
+                        {
+                            ids.Add(episodeId);
+                            item.MediaItemId = episodeId;
+                        }
+
+                        break;
+                }
+            }
+
+            await dbContext.SaveChangesAsync();
+
+            foreach (int mediaItemId in ids)
+            {
+                Option<MediaItem> maybeItem = await _searchRepository.GetItemToIndex(mediaItemId);
+                foreach (MediaItem item in maybeItem)
+                {
+                    await _searchIndex.UpdateItems(_searchRepository, new[] { item }.ToList());
+                }
+            }
+
+            _searchIndex.Commit();
+
+            return list;
         }
-        
-        private async Task<Option<int>> IdentifyMovie(TvContext dbContext, TraktListItem item)
+        catch (Exception ex)
         {
-            var guids = item.Guids.Map(g => g.Guid).ToList();
-            
-            Option<int> maybeMovieByGuid = await dbContext.MovieMetadata
-                .AsNoTracking()
-                .Filter(mm => mm.Guids.Any(g => guids.Contains(g.Guid)))
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(mm => mm.MovieId);
-
-            foreach (int movieId in maybeMovieByGuid)
-            {
-                _logger.LogDebug("Located trakt movie {Title} by id", item.DisplayTitle);
-                return movieId;
-            }
-
-            Option<int> maybeMovieByTitleYear = await dbContext.MovieMetadata
-                .AsNoTracking()
-                .Filter(mm => mm.Title == item.Title && mm.Year == item.Year)
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(mm => mm.MovieId);
-
-            foreach (int movieId in maybeMovieByTitleYear)
-            {
-                _logger.LogDebug("Located trakt movie {Title} by title/year", item.DisplayTitle);
-                return movieId;
-            }
-
-            _logger.LogDebug("Unable to locate trakt movie {Title}", item.DisplayTitle);
-
-            return None;
-        }
-
-        private async Task<Option<int>> IdentifyShow(TvContext dbContext, TraktListItem item)
-        {
-            var guids = item.Guids.Map(g => g.Guid).ToList();
-
-            Option<int> maybeShowByGuid = await dbContext.ShowMetadata
-                .AsNoTracking()
-                .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(sm => sm.ShowId);
-
-            foreach (int showId in maybeShowByGuid)
-            {
-                _logger.LogDebug("Located trakt show {Title} by id", item.DisplayTitle);
-                return showId;
-            }
-
-            Option<int> maybeShowByTitleYear = await dbContext.ShowMetadata
-                .AsNoTracking()
-                .Filter(sm => sm.Title == item.Title && sm.Year == item.Year)
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(sm => sm.ShowId);
-
-            foreach (int showId in maybeShowByTitleYear)
-            {
-                _logger.LogDebug("Located trakt show {Title} by title/year", item.Title);
-                return showId;
-            }
-
-            _logger.LogDebug("Unable to locate trakt show {Title}", item.DisplayTitle);
-
-            return None;
-        }
-        
-        private async Task<Option<int>> IdentifySeason(TvContext dbContext, TraktListItem item)
-        {
-            var guids = item.Guids.Map(g => g.Guid).ToList();
-
-            Option<int> maybeSeasonByGuid = await dbContext.SeasonMetadata
-                .AsNoTracking()
-                .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(sm => sm.SeasonId);
-
-            foreach (int seasonId in maybeSeasonByGuid)
-            {
-                _logger.LogDebug("Located trakt season {Title} by id", item.DisplayTitle);
-                return seasonId;
-            }
-
-            Option<int> maybeSeasonByTitleYear = await dbContext.SeasonMetadata
-                .AsNoTracking()
-                .Filter(sm => sm.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
-                .Filter(sm => sm.Season.SeasonNumber == item.Season)
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(sm => sm.SeasonId);
-
-            foreach (int seasonId in maybeSeasonByTitleYear)
-            {
-                _logger.LogDebug("Located trakt season {Title} by title/year/season", item.DisplayTitle);
-                return seasonId;
-            }
-
-            _logger.LogDebug("Unable to locate trakt season {Title}", item.DisplayTitle);
-
-            return None;
-        }
-        
-        private async Task<Option<int>> IdentifyEpisode(TvContext dbContext, TraktListItem item)
-        {
-            var guids = item.Guids.Map(g => g.Guid).ToList();
-
-            Option<int> maybeEpisodeByGuid = await dbContext.EpisodeMetadata
-                .AsNoTracking()
-                .Filter(em => em.Guids.Any(g => guids.Contains(g.Guid)))
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(sm => sm.EpisodeId);
-
-            foreach (int episodeId in maybeEpisodeByGuid)
-            {
-                _logger.LogDebug("Located trakt episode {Title} by id", item.DisplayTitle);
-                return episodeId;
-            }
-
-            Option<int> maybeEpisodeByTitleYear = await dbContext.EpisodeMetadata
-                .AsNoTracking()
-                .Filter(sm => sm.Episode.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
-                .Filter(em => em.Episode.Season.SeasonNumber == item.Season)
-                .Filter(sm => sm.Episode.EpisodeMetadata.Any(e => e.EpisodeNumber == item.Episode))
-                .FirstOrDefaultAsync()
-                .Map(Optional)
-                .MapT(sm => sm.EpisodeId);
-
-            foreach (int episodeId in maybeEpisodeByTitleYear)
-            {
-                _logger.LogDebug("Located trakt episode {Title} by title/year/season/episode", item.DisplayTitle);
-                return episodeId;
-            }
-
-            _logger.LogDebug("Unable to locate trakt episode {Title}", item.DisplayTitle);
-
-            return None;
+            _logger.LogError(ex, "Error matching trakt list items");
+            return BaseError.New(ex.Message);
         }
     }
-}
+
+    private static TraktListItem ProjectItem(TraktList list, TraktListItemWithGuids item)
+    {
+        var result = new TraktListItem
+        {
+            TraktList = list,
+            Kind = item.Kind,
+            TraktId = item.TraktId,
+            Rank = item.Rank,
+            Title = item.Title,
+            Year = item.Year,
+            Season = item.Season,
+            Episode = item.Episode,
+        };
+
+        result.Guids = item.Guids.Map(g => new TraktListItemGuid { Guid = g, TraktListItem = result }).ToList();
+
+        return result;
+    }
+        
+    private async Task<Option<int>> IdentifyMovie(TvContext dbContext, TraktListItem item)
+    {
+        var guids = item.Guids.Map(g => g.Guid).ToList();
+            
+        Option<int> maybeMovieByGuid = await dbContext.MovieMetadata
+            .AsNoTracking()
+            .Filter(mm => mm.Guids.Any(g => guids.Contains(g.Guid)))
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(mm => mm.MovieId);
+
+        foreach (int movieId in maybeMovieByGuid)
+        {
+            _logger.LogDebug("Located trakt movie {Title} by id", item.DisplayTitle);
+            return movieId;
+        }
+
+        Option<int> maybeMovieByTitleYear = await dbContext.MovieMetadata
+            .AsNoTracking()
+            .Filter(mm => mm.Title == item.Title && mm.Year == item.Year)
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(mm => mm.MovieId);
+
+        foreach (int movieId in maybeMovieByTitleYear)
+        {
+            _logger.LogDebug("Located trakt movie {Title} by title/year", item.DisplayTitle);
+            return movieId;
+        }
+
+        _logger.LogDebug("Unable to locate trakt movie {Title}", item.DisplayTitle);
+
+        return None;
+    }
+
+    private async Task<Option<int>> IdentifyShow(TvContext dbContext, TraktListItem item)
+    {
+        var guids = item.Guids.Map(g => g.Guid).ToList();
+
+        Option<int> maybeShowByGuid = await dbContext.ShowMetadata
+            .AsNoTracking()
+            .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(sm => sm.ShowId);
+
+        foreach (int showId in maybeShowByGuid)
+        {
+            _logger.LogDebug("Located trakt show {Title} by id", item.DisplayTitle);
+            return showId;
+        }
+
+        Option<int> maybeShowByTitleYear = await dbContext.ShowMetadata
+            .AsNoTracking()
+            .Filter(sm => sm.Title == item.Title && sm.Year == item.Year)
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(sm => sm.ShowId);
+
+        foreach (int showId in maybeShowByTitleYear)
+        {
+            _logger.LogDebug("Located trakt show {Title} by title/year", item.Title);
+            return showId;
+        }
+
+        _logger.LogDebug("Unable to locate trakt show {Title}", item.DisplayTitle);
+
+        return None;
+    }
+        
+    private async Task<Option<int>> IdentifySeason(TvContext dbContext, TraktListItem item)
+    {
+        var guids = item.Guids.Map(g => g.Guid).ToList();
+
+        Option<int> maybeSeasonByGuid = await dbContext.SeasonMetadata
+            .AsNoTracking()
+            .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(sm => sm.SeasonId);
+
+        foreach (int seasonId in maybeSeasonByGuid)
+        {
+            _logger.LogDebug("Located trakt season {Title} by id", item.DisplayTitle);
+            return seasonId;
+        }
+
+        Option<int> maybeSeasonByTitleYear = await dbContext.SeasonMetadata
+            .AsNoTracking()
+            .Filter(sm => sm.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
+            .Filter(sm => sm.Season.SeasonNumber == item.Season)
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(sm => sm.SeasonId);
+
+        foreach (int seasonId in maybeSeasonByTitleYear)
+        {
+            _logger.LogDebug("Located trakt season {Title} by title/year/season", item.DisplayTitle);
+            return seasonId;
+        }
+
+        _logger.LogDebug("Unable to locate trakt season {Title}", item.DisplayTitle);
+
+        return None;
+    }
+        
+    private async Task<Option<int>> IdentifyEpisode(TvContext dbContext, TraktListItem item)
+    {
+        var guids = item.Guids.Map(g => g.Guid).ToList();
+
+        Option<int> maybeEpisodeByGuid = await dbContext.EpisodeMetadata
+            .AsNoTracking()
+            .Filter(em => em.Guids.Any(g => guids.Contains(g.Guid)))
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(sm => sm.EpisodeId);
+
+        foreach (int episodeId in maybeEpisodeByGuid)
+        {
+            _logger.LogDebug("Located trakt episode {Title} by id", item.DisplayTitle);
+            return episodeId;
+        }
+
+        Option<int> maybeEpisodeByTitleYear = await dbContext.EpisodeMetadata
+            .AsNoTracking()
+            .Filter(sm => sm.Episode.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
+            .Filter(em => em.Episode.Season.SeasonNumber == item.Season)
+            .Filter(sm => sm.Episode.EpisodeMetadata.Any(e => e.EpisodeNumber == item.Episode))
+            .FirstOrDefaultAsync()
+            .Map(Optional)
+            .MapT(sm => sm.EpisodeId);
+
+        foreach (int episodeId in maybeEpisodeByTitleYear)
+        {
+            _logger.LogDebug("Located trakt episode {Title} by title/year/season/episode", item.DisplayTitle);
+            return episodeId;
+        }
+
+        _logger.LogDebug("Unable to locate trakt episode {Title}", item.DisplayTitle);
+
+        return None;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/UpdateCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/UpdateCollection.cs
index 1661fd2ce..887211a79 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateCollection.cs
@@ -1,12 +1,9 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public record UpdateCollection
+    (int CollectionId, string Name) : MediatR.IRequest<Either<BaseError, Unit>>
 {
-    public record UpdateCollection
-        (int CollectionId, string Name) : MediatR.IRequest<Either<BaseError, Unit>>
-    {
-        public Option<bool> UseCustomPlaybackOrder { get; set; } = None;
-    }
-}
+    public Option<bool> UseCustomPlaybackOrder { get; set; } = None;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrder.cs b/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrder.cs
index 6a8f2f024..b8b565112 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrder.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrder.cs
@@ -1,13 +1,10 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record UpdateCollectionCustomOrder
-    (
-        int CollectionId,
-        List<MediaItemCustomOrder> MediaItemCustomOrders) : MediatR.IRequest<Either<BaseError, Unit>>;
+namespace ErsatzTV.Application.MediaCollections;
 
-    public record MediaItemCustomOrder(int MediaItemId, int CustomIndex);
-}
+public record UpdateCollectionCustomOrder
+(
+    int CollectionId,
+    List<MediaItemCustomOrder> MediaItemCustomOrders) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+public record MediaItemCustomOrder(int MediaItemId, int CustomIndex);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrderHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrderHandler.cs
index a40add059..903983a95 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrderHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionCustomOrderHandler.cs
@@ -1,84 +1,79 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class UpdateCollectionCustomOrderHandler :
+    MediatR.IRequestHandler<UpdateCollectionCustomOrder, Either<BaseError, Unit>>
 {
-    public class UpdateCollectionCustomOrderHandler :
-        MediatR.IRequestHandler<UpdateCollectionCustomOrder, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public UpdateCollectionCustomOrderHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public UpdateCollectionCustomOrderHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            UpdateCollectionCustomOrder request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
-        }
-
-        private async Task<Unit> ApplyUpdateRequest(
-            TvContext dbContext,
-            Collection c,
-            UpdateCollectionCustomOrder request)
-        {
-            foreach (MediaItemCustomOrder updateItem in request.MediaItemCustomOrders)
-            {
-                Option<CollectionItem> maybeCollectionItem = c.CollectionItems
-                    .FirstOrDefault(ci => ci.MediaItemId == updateItem.MediaItemId);
-
-                foreach (CollectionItem collectionItem in maybeCollectionItem)
-                {
-                    collectionItem.CustomIndex = updateItem.CustomIndex;
-                }
-            }
-
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository
-                    .PlayoutIdsUsingCollection(request.CollectionId))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, Collection>> Validate(
-            TvContext dbContext,
-            UpdateCollectionCustomOrder request) =>
-            CollectionMustExist(dbContext, request);
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            UpdateCollectionCustomOrder request) =>
-            dbContext.Collections
-                .Include(c => c.CollectionItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateCollectionCustomOrder request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Collection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+    }
+
+    private async Task<Unit> ApplyUpdateRequest(
+        TvContext dbContext,
+        Collection c,
+        UpdateCollectionCustomOrder request)
+    {
+        foreach (MediaItemCustomOrder updateItem in request.MediaItemCustomOrders)
+        {
+            Option<CollectionItem> maybeCollectionItem = c.CollectionItems
+                .FirstOrDefault(ci => ci.MediaItemId == updateItem.MediaItemId);
+
+            foreach (CollectionItem collectionItem in maybeCollectionItem)
+            {
+                collectionItem.CustomIndex = updateItem.CustomIndex;
+            }
+        }
+
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository
+                         .PlayoutIdsUsingCollection(request.CollectionId))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, Collection>> Validate(
+        TvContext dbContext,
+        UpdateCollectionCustomOrder request) =>
+        CollectionMustExist(dbContext, request);
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        UpdateCollectionCustomOrder request) =>
+        dbContext.Collections
+            .Include(c => c.CollectionItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs
index 2d7847d05..067fa4e0e 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateCollectionHandler.cs
@@ -1,78 +1,74 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class UpdateCollectionHandler : MediatR.IRequestHandler<UpdateCollection, Either<BaseError, Unit>>
 {
-    public class UpdateCollectionHandler : MediatR.IRequestHandler<UpdateCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public UpdateCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public UpdateCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            UpdateCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Collection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
-        }
-
-        private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, Collection c, UpdateCollection request)
-        {
-            c.Name = request.Name;
-            foreach (bool useCustomPlaybackOrder in request.UseCustomPlaybackOrder)
-            {
-                c.UseCustomPlaybackOrder = useCustomPlaybackOrder;
-            }
-
-            if (await dbContext.SaveChangesAsync() > 0 && request.UseCustomPlaybackOrder.IsSome)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(
-                    request.CollectionId))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, Collection>> Validate(
-            TvContext dbContext,
-            UpdateCollection request) =>
-            (await CollectionMustExist(dbContext, request), ValidateName(request))
-            .Apply((collectionToUpdate, _) => collectionToUpdate);
-
-        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
-            TvContext dbContext,
-            UpdateCollection updateCollection) =>
-            dbContext.Collections
-                .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.CollectionId)
-                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
-
-        private static Validation<BaseError, string> ValidateName(UpdateCollection updateSimpleMediaCollection) =>
-            updateSimpleMediaCollection.NotEmpty(c => c.Name)
-                .Bind(_ => updateSimpleMediaCollection.NotLongerThan(50)(c => c.Name));
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Collection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+    }
+
+    private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, Collection c, UpdateCollection request)
+    {
+        c.Name = request.Name;
+        foreach (bool useCustomPlaybackOrder in request.UseCustomPlaybackOrder)
+        {
+            c.UseCustomPlaybackOrder = useCustomPlaybackOrder;
+        }
+
+        if (await dbContext.SaveChangesAsync() > 0 && request.UseCustomPlaybackOrder.IsSome)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingCollection(
+                         request.CollectionId))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, Collection>> Validate(
+        TvContext dbContext,
+        UpdateCollection request) =>
+        (await CollectionMustExist(dbContext, request), ValidateName(request))
+        .Apply((collectionToUpdate, _) => collectionToUpdate);
+
+    private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+        TvContext dbContext,
+        UpdateCollection updateCollection) =>
+        dbContext.Collections
+            .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.CollectionId)
+            .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+    private static Validation<BaseError, string> ValidateName(UpdateCollection updateSimpleMediaCollection) =>
+        updateSimpleMediaCollection.NotEmpty(c => c.Name)
+            .Bind(_ => updateSimpleMediaCollection.NotLongerThan(50)(c => c.Name));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollection.cs
index ad8bf890a..017afe549 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollection.cs
@@ -1,15 +1,12 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record UpdateMultiCollectionItem(int? CollectionId, int? SmartCollectionId, bool ScheduleAsGroup, PlaybackOrder PlaybackOrder);
+namespace ErsatzTV.Application.MediaCollections;
 
-    public record UpdateMultiCollection
-    (
-        int MultiCollectionId,
-        string Name,
-        List<UpdateMultiCollectionItem> Items) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+public record UpdateMultiCollectionItem(int? CollectionId, int? SmartCollectionId, bool ScheduleAsGroup, PlaybackOrder PlaybackOrder);
+
+public record UpdateMultiCollection
+(
+    int MultiCollectionId,
+    string Name,
+    List<UpdateMultiCollectionItem> Items) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollectionHandler.cs
index 36c6cdb0a..f56093f89 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollectionHandler.cs
@@ -1,165 +1,157 @@
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiCollection, Either<BaseError, Unit>>
 {
-    public class UpdateMultiCollectionHandler : MediatR.IRequestHandler<UpdateMultiCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public UpdateMultiCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public UpdateMultiCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            UpdateMultiCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, MultiCollection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
-        }
-
-        private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, MultiCollection c, UpdateMultiCollection request)
-        {
-            c.Name = request.Name;
-            
-            // save name first so playouts don't get rebuilt for a name change
-            await dbContext.SaveChangesAsync();
-
-            var toAdd = request.Items
-                .Filter(i => i.CollectionId.HasValue)
-                // ReSharper disable once PossibleInvalidOperationException
-                .Filter(i => c.MultiCollectionItems.All(i2 => i2.CollectionId != i.CollectionId.Value))
-                .Map(i => new MultiCollectionItem
-                    {
-                        // ReSharper disable once PossibleInvalidOperationException
-                        CollectionId = i.CollectionId.Value,
-                        MultiCollectionId = c.Id,
-                        ScheduleAsGroup = i.ScheduleAsGroup,
-                        PlaybackOrder = i.PlaybackOrder
-                    })
-                .ToList();
-            var toRemove = c.MultiCollectionItems
-                .Filter(i => request.Items.All(i2 => i2.CollectionId != i.CollectionId))
-                .ToList();
-            
-            // remove items that are no longer present
-            c.MultiCollectionItems.RemoveAll(toRemove.Contains);
-            
-            // update existing items
-            foreach (MultiCollectionItem item in c.MultiCollectionItems)
-            {
-                foreach (UpdateMultiCollectionItem incoming in request.Items.Filter(
-                    i => i.CollectionId == item.CollectionId))
-                {
-                    item.ScheduleAsGroup = incoming.ScheduleAsGroup;
-                    item.PlaybackOrder = incoming.PlaybackOrder;
-                }
-            }
-
-            // add new items
-            c.MultiCollectionItems.AddRange(toAdd);
-
-            var toAddSmart = request.Items
-                .Filter(i => i.SmartCollectionId.HasValue)
-                // ReSharper disable once PossibleInvalidOperationException
-                .Filter(i => c.MultiCollectionSmartItems.All(i2 => i2.SmartCollectionId != i.SmartCollectionId.Value))
-                .Map(i => new MultiCollectionSmartItem
-                    {
-                        // ReSharper disable once PossibleInvalidOperationException
-                        SmartCollectionId = i.SmartCollectionId.Value,
-                        MultiCollectionId = c.Id,
-                        ScheduleAsGroup = i.ScheduleAsGroup,
-                        PlaybackOrder = i.PlaybackOrder
-                    })
-                .ToList();
-            var toRemoveSmart = c.MultiCollectionSmartItems
-                .Filter(i => request.Items.All(i2 => i2.SmartCollectionId != i.SmartCollectionId))
-                .ToList();
-            
-            // remove items that are no longer present
-            c.MultiCollectionSmartItems.RemoveAll(toRemoveSmart.Contains);
-            
-            // update existing items
-            foreach (MultiCollectionSmartItem item in c.MultiCollectionSmartItems)
-            {
-                foreach (UpdateMultiCollectionItem incoming in request.Items.Filter(
-                    i => i.SmartCollectionId == item.SmartCollectionId))
-                {
-                    item.ScheduleAsGroup = incoming.ScheduleAsGroup;
-                    item.PlaybackOrder = incoming.PlaybackOrder;
-                }
-            }
-
-            // add new items
-            c.MultiCollectionSmartItems.AddRange(toAddSmart);
-
-            // rebuild playouts
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this collection
-                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingMultiCollection(
-                    request.MultiCollectionId))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static async Task<Validation<BaseError, MultiCollection>> Validate(
-            TvContext dbContext,
-            UpdateMultiCollection request) =>
-            (await MultiCollectionMustExist(dbContext, request), await ValidateName(dbContext, request))
-            .Apply((collectionToUpdate, _) => collectionToUpdate);
-
-        private static Task<Validation<BaseError, MultiCollection>> MultiCollectionMustExist(
-            TvContext dbContext,
-            UpdateMultiCollection updateCollection) =>
-            dbContext.MultiCollections
-                .Include(mc => mc.MultiCollectionItems)
-                .Include(mc => mc.MultiCollectionSmartItems)
-                .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.MultiCollectionId)
-                .Map(o => o.ToValidation<BaseError>("MultiCollection does not exist."));
-
-        private static async Task<Validation<BaseError, string>> ValidateName(TvContext dbContext, UpdateMultiCollection updateMultiCollection)
-        {
-            List<string> allNames = await dbContext.MultiCollections
-                .Filter(mc => mc.Id != updateMultiCollection.MultiCollectionId)
-                .Map(c => c.Name)
-                .ToListAsync();
-
-            Validation<BaseError, string> result1 = updateMultiCollection.NotEmpty(c => c.Name)
-                .Bind(_ => updateMultiCollection.NotLongerThan(50)(c => c.Name));
-
-            var result2 = Optional(updateMultiCollection.Name)
-                .Where(name => !allNames.Contains(name))
-                .ToValidation<BaseError>("MultiCollection name must be unique");
-
-            return (result1, result2).Apply((_, _) => updateMultiCollection.Name);
-        }
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateMultiCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, MultiCollection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+    }
+
+    private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, MultiCollection c, UpdateMultiCollection request)
+    {
+        c.Name = request.Name;
+            
+        // save name first so playouts don't get rebuilt for a name change
+        await dbContext.SaveChangesAsync();
+
+        var toAdd = request.Items
+            .Filter(i => i.CollectionId.HasValue)
+            // ReSharper disable once PossibleInvalidOperationException
+            .Filter(i => c.MultiCollectionItems.All(i2 => i2.CollectionId != i.CollectionId.Value))
+            .Map(i => new MultiCollectionItem
+            {
+                // ReSharper disable once PossibleInvalidOperationException
+                CollectionId = i.CollectionId.Value,
+                MultiCollectionId = c.Id,
+                ScheduleAsGroup = i.ScheduleAsGroup,
+                PlaybackOrder = i.PlaybackOrder
+            })
+            .ToList();
+        var toRemove = c.MultiCollectionItems
+            .Filter(i => request.Items.All(i2 => i2.CollectionId != i.CollectionId))
+            .ToList();
+            
+        // remove items that are no longer present
+        c.MultiCollectionItems.RemoveAll(toRemove.Contains);
+            
+        // update existing items
+        foreach (MultiCollectionItem item in c.MultiCollectionItems)
+        {
+            foreach (UpdateMultiCollectionItem incoming in request.Items.Filter(
+                         i => i.CollectionId == item.CollectionId))
+            {
+                item.ScheduleAsGroup = incoming.ScheduleAsGroup;
+                item.PlaybackOrder = incoming.PlaybackOrder;
+            }
+        }
+
+        // add new items
+        c.MultiCollectionItems.AddRange(toAdd);
+
+        var toAddSmart = request.Items
+            .Filter(i => i.SmartCollectionId.HasValue)
+            // ReSharper disable once PossibleInvalidOperationException
+            .Filter(i => c.MultiCollectionSmartItems.All(i2 => i2.SmartCollectionId != i.SmartCollectionId.Value))
+            .Map(i => new MultiCollectionSmartItem
+            {
+                // ReSharper disable once PossibleInvalidOperationException
+                SmartCollectionId = i.SmartCollectionId.Value,
+                MultiCollectionId = c.Id,
+                ScheduleAsGroup = i.ScheduleAsGroup,
+                PlaybackOrder = i.PlaybackOrder
+            })
+            .ToList();
+        var toRemoveSmart = c.MultiCollectionSmartItems
+            .Filter(i => request.Items.All(i2 => i2.SmartCollectionId != i.SmartCollectionId))
+            .ToList();
+            
+        // remove items that are no longer present
+        c.MultiCollectionSmartItems.RemoveAll(toRemoveSmart.Contains);
+            
+        // update existing items
+        foreach (MultiCollectionSmartItem item in c.MultiCollectionSmartItems)
+        {
+            foreach (UpdateMultiCollectionItem incoming in request.Items.Filter(
+                         i => i.SmartCollectionId == item.SmartCollectionId))
+            {
+                item.ScheduleAsGroup = incoming.ScheduleAsGroup;
+                item.PlaybackOrder = incoming.PlaybackOrder;
+            }
+        }
+
+        // add new items
+        c.MultiCollectionSmartItems.AddRange(toAddSmart);
+
+        // rebuild playouts
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this collection
+            foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingMultiCollection(
+                         request.MultiCollectionId))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static async Task<Validation<BaseError, MultiCollection>> Validate(
+        TvContext dbContext,
+        UpdateMultiCollection request) =>
+        (await MultiCollectionMustExist(dbContext, request), await ValidateName(dbContext, request))
+        .Apply((collectionToUpdate, _) => collectionToUpdate);
+
+    private static Task<Validation<BaseError, MultiCollection>> MultiCollectionMustExist(
+        TvContext dbContext,
+        UpdateMultiCollection updateCollection) =>
+        dbContext.MultiCollections
+            .Include(mc => mc.MultiCollectionItems)
+            .Include(mc => mc.MultiCollectionSmartItems)
+            .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.MultiCollectionId)
+            .Map(o => o.ToValidation<BaseError>("MultiCollection does not exist."));
+
+    private static async Task<Validation<BaseError, string>> ValidateName(TvContext dbContext, UpdateMultiCollection updateMultiCollection)
+    {
+        List<string> allNames = await dbContext.MultiCollections
+            .Filter(mc => mc.Id != updateMultiCollection.MultiCollectionId)
+            .Map(c => c.Name)
+            .ToListAsync();
+
+        Validation<BaseError, string> result1 = updateMultiCollection.NotEmpty(c => c.Name)
+            .Bind(_ => updateMultiCollection.NotLongerThan(50)(c => c.Name));
+
+        var result2 = Optional(updateMultiCollection.Name)
+            .Where(name => !allNames.Contains(name))
+            .ToValidation<BaseError>("MultiCollection name must be unique");
+
+        return (result1, result2).Apply((_, _) => updateMultiCollection.Name);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollection.cs b/ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollection.cs
index 6ee1df3ed..bbb1d115a 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollection.cs
@@ -1,9 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
-{
-    public record UpdateSmartCollection(int Id, string Query) : IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record UpdateSmartCollection(int Id, string Query) : IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollectionHandler.cs b/ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollectionHandler.cs
index 3fab12b94..e48a89563 100644
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateSmartCollectionHandler.cs
@@ -1,71 +1,64 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.MediaCollections.Commands
+namespace ErsatzTV.Application.MediaCollections;
+
+public class UpdateSmartCollectionHandler : MediatR.IRequestHandler<UpdateSmartCollection, Either<BaseError, Unit>>
 {
-    public class UpdateSmartCollectionHandler : MediatR.IRequestHandler<UpdateSmartCollection, Either<BaseError, Unit>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+    public UpdateSmartCollectionHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-
-        public UpdateSmartCollectionHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            UpdateSmartCollection request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request);
-            return await validation.Apply(c => ApplyUpdateRequest(dbContext, c, request));
-        }
-
-        private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, SmartCollection c, UpdateSmartCollection request)
-        {
-            c.Query = request.Query;
-
-            // rebuild playouts
-            if (await dbContext.SaveChangesAsync() > 0)
-            {
-                // rebuild all playouts that use this smart collection
-                foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingSmartCollection(request.Id))
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, SmartCollection>> Validate(
-            TvContext dbContext,
-            UpdateSmartCollection request) => SmartCollectionMustExist(dbContext, request);
-
-        private static Task<Validation<BaseError, SmartCollection>> SmartCollectionMustExist(
-            TvContext dbContext,
-            UpdateSmartCollection updateCollection) =>
-            dbContext.SmartCollections
-                .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.Id)
-                .Map(o => o.ToValidation<BaseError>("SmartCollection does not exist."));
+        _dbContextFactory = dbContextFactory;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdateSmartCollection request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, SmartCollection> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, c => ApplyUpdateRequest(dbContext, c, request));
+    }
+
+    private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, SmartCollection c, UpdateSmartCollection request)
+    {
+        c.Query = request.Query;
+
+        // rebuild playouts
+        if (await dbContext.SaveChangesAsync() > 0)
+        {
+            // rebuild all playouts that use this smart collection
+            foreach (int playoutId in await _mediaCollectionRepository.PlayoutIdsUsingSmartCollection(request.Id))
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, SmartCollection>> Validate(
+        TvContext dbContext,
+        UpdateSmartCollection request) => SmartCollectionMustExist(dbContext, request);
+
+    private static Task<Validation<BaseError, SmartCollection>> SmartCollectionMustExist(
+        TvContext dbContext,
+        UpdateSmartCollection updateCollection) =>
+        dbContext.SmartCollections
+            .SelectOneAsync(c => c.Id, c => c.Id == updateCollection.Id)
+            .Map(o => o.ToValidation<BaseError>("SmartCollection does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Mapper.cs b/ErsatzTV.Application/MediaCollections/Mapper.cs
index 4fffe975c..688a4b144 100644
--- a/ErsatzTV.Application/MediaCollections/Mapper.cs
+++ b/ErsatzTV.Application/MediaCollections/Mapper.cs
@@ -1,45 +1,42 @@
-using System.Linq;
-using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCollections
+namespace ErsatzTV.Application.MediaCollections;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static MediaCollectionViewModel ProjectToViewModel(Collection collection) =>
-            new(collection.Id, collection.Name, collection.UseCustomPlaybackOrder, MediaItemState.Normal);
+    internal static MediaCollectionViewModel ProjectToViewModel(Collection collection) =>
+        new(collection.Id, collection.Name, collection.UseCustomPlaybackOrder, MediaItemState.Normal);
 
-        internal static MultiCollectionViewModel ProjectToViewModel(MultiCollection multiCollection) =>
-            new(
-                multiCollection.Id,
-                multiCollection.Name,
-                Optional(multiCollection.MultiCollectionItems).Flatten().Map(ProjectToViewModel).ToList(),
-                Optional(multiCollection.MultiCollectionSmartItems).Flatten().Map(ProjectToViewModel).ToList());
+    internal static MultiCollectionViewModel ProjectToViewModel(MultiCollection multiCollection) =>
+        new(
+            multiCollection.Id,
+            multiCollection.Name,
+            Optional(multiCollection.MultiCollectionItems).Flatten().Map(ProjectToViewModel).ToList(),
+            Optional(multiCollection.MultiCollectionSmartItems).Flatten().Map(ProjectToViewModel).ToList());
 
-        internal static SmartCollectionViewModel ProjectToViewModel(SmartCollection collection) =>
-            new(collection.Id, collection.Name, collection.Query);
+    internal static SmartCollectionViewModel ProjectToViewModel(SmartCollection collection) =>
+        new(collection.Id, collection.Name, collection.Query);
 
-        internal static TraktListViewModel ProjectToViewModel(TraktList traktList) =>
-            new(
-                traktList.Id,
-                traktList.TraktId,
-                $"{traktList.User}/{traktList.List}",
-                traktList.Name,
-                traktList.ItemCount,
-                traktList.Items.Count(i => i.MediaItemId.HasValue));
+    internal static TraktListViewModel ProjectToViewModel(TraktList traktList) =>
+        new(
+            traktList.Id,
+            traktList.TraktId,
+            $"{traktList.User}/{traktList.List}",
+            traktList.Name,
+            traktList.ItemCount,
+            traktList.Items.Count(i => i.MediaItemId.HasValue));
 
-        private static MultiCollectionItemViewModel ProjectToViewModel(MultiCollectionItem multiCollectionItem) =>
-            new(
-                multiCollectionItem.MultiCollectionId,
-                ProjectToViewModel(multiCollectionItem.Collection),
-                multiCollectionItem.ScheduleAsGroup,
-                multiCollectionItem.PlaybackOrder);
+    private static MultiCollectionItemViewModel ProjectToViewModel(MultiCollectionItem multiCollectionItem) =>
+        new(
+            multiCollectionItem.MultiCollectionId,
+            ProjectToViewModel(multiCollectionItem.Collection),
+            multiCollectionItem.ScheduleAsGroup,
+            multiCollectionItem.PlaybackOrder);
 
-        private static MultiCollectionSmartItemViewModel ProjectToViewModel(MultiCollectionSmartItem multiCollectionSmartItem) =>
-            new(
-                multiCollectionSmartItem.MultiCollectionId,
-                ProjectToViewModel(multiCollectionSmartItem.SmartCollection),
-                multiCollectionSmartItem.ScheduleAsGroup,
-                multiCollectionSmartItem.PlaybackOrder);
-    }
-}
+    private static MultiCollectionSmartItemViewModel ProjectToViewModel(MultiCollectionSmartItem multiCollectionSmartItem) =>
+        new(
+            multiCollectionSmartItem.MultiCollectionId,
+            ProjectToViewModel(multiCollectionSmartItem.SmartCollection),
+            multiCollectionSmartItem.ScheduleAsGroup,
+            multiCollectionSmartItem.PlaybackOrder);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/MediaCollectionSummaryViewModel.cs b/ErsatzTV.Application/MediaCollections/MediaCollectionSummaryViewModel.cs
index 1a9d552f3..3aacaa275 100644
--- a/ErsatzTV.Application/MediaCollections/MediaCollectionSummaryViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/MediaCollectionSummaryViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record MediaCollectionSummaryViewModel(int Id, string Name, int ItemCount, bool IsSimple);
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record MediaCollectionSummaryViewModel(int Id, string Name, int ItemCount, bool IsSimple);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs b/ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs
index e0cefedb8..81c768352 100644
--- a/ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/MediaCollectionViewModel.cs
@@ -1,17 +1,16 @@
 using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record MediaCollectionViewModel(
-        int Id,
-        string Name,
-        bool UseCustomPlaybackOrder,
-        MediaItemState State) : MediaCardViewModel(
-        Id,
-        Name,
-        string.Empty,
-        Name,
-        string.Empty,
-        State);
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record MediaCollectionViewModel(
+    int Id,
+    string Name,
+    bool UseCustomPlaybackOrder,
+    MediaItemState State) : MediaCardViewModel(
+    Id,
+    Name,
+    string.Empty,
+    Name,
+    string.Empty,
+    State);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/MultiCollectionItemViewModel.cs b/ErsatzTV.Application/MediaCollections/MultiCollectionItemViewModel.cs
index eb0757c93..38d71eb4a 100644
--- a/ErsatzTV.Application/MediaCollections/MultiCollectionItemViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/MultiCollectionItemViewModel.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record MultiCollectionItemViewModel(
-        int MultiCollectionId,
-        MediaCollectionViewModel Collection,
-        bool ScheduleAsGroup,
-        PlaybackOrder PlaybackOrder);
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record MultiCollectionItemViewModel(
+    int MultiCollectionId,
+    MediaCollectionViewModel Collection,
+    bool ScheduleAsGroup,
+    PlaybackOrder PlaybackOrder);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/MultiCollectionSmartItemViewModel.cs b/ErsatzTV.Application/MediaCollections/MultiCollectionSmartItemViewModel.cs
index a4202a2f4..46adfa4a8 100644
--- a/ErsatzTV.Application/MediaCollections/MultiCollectionSmartItemViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/MultiCollectionSmartItemViewModel.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record MultiCollectionSmartItemViewModel(
-        int MultiCollectionId,
-        SmartCollectionViewModel SmartCollection,
-        bool ScheduleAsGroup,
-        PlaybackOrder PlaybackOrder);
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record MultiCollectionSmartItemViewModel(
+    int MultiCollectionId,
+    SmartCollectionViewModel SmartCollection,
+    bool ScheduleAsGroup,
+    PlaybackOrder PlaybackOrder);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/MultiCollectionViewModel.cs b/ErsatzTV.Application/MediaCollections/MultiCollectionViewModel.cs
index 0e581a115..5cc6bfdd8 100644
--- a/ErsatzTV.Application/MediaCollections/MultiCollectionViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/MultiCollectionViewModel.cs
@@ -1,10 +1,7 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record MultiCollectionViewModel(
-        int Id,
-        string Name,
-        List<MultiCollectionItemViewModel> Items,
-        List<MultiCollectionSmartItemViewModel> SmartItems);
-}
+public record MultiCollectionViewModel(
+    int Id,
+    string Name,
+    List<MultiCollectionItemViewModel> Items,
+    List<MultiCollectionSmartItemViewModel> SmartItems);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/PagedMediaCollectionsViewModel.cs b/ErsatzTV.Application/MediaCollections/PagedMediaCollectionsViewModel.cs
index bde112dc0..dfef499c3 100644
--- a/ErsatzTV.Application/MediaCollections/PagedMediaCollectionsViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/PagedMediaCollectionsViewModel.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record PagedMediaCollectionsViewModel(int TotalCount, List<MediaCollectionViewModel> Page);
-}
+public record PagedMediaCollectionsViewModel(int TotalCount, List<MediaCollectionViewModel> Page);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/PagedMultiCollectionsViewModel.cs b/ErsatzTV.Application/MediaCollections/PagedMultiCollectionsViewModel.cs
index f0318701a..e03dbe56d 100644
--- a/ErsatzTV.Application/MediaCollections/PagedMultiCollectionsViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/PagedMultiCollectionsViewModel.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record PagedMultiCollectionsViewModel(int TotalCount, List<MultiCollectionViewModel> Page);
-}
+public record PagedMultiCollectionsViewModel(int TotalCount, List<MultiCollectionViewModel> Page);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/PagedSmartCollectionsViewModel.cs b/ErsatzTV.Application/MediaCollections/PagedSmartCollectionsViewModel.cs
index 4b761022d..5bf17cb0a 100644
--- a/ErsatzTV.Application/MediaCollections/PagedSmartCollectionsViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/PagedSmartCollectionsViewModel.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record PagedSmartCollectionsViewModel(int TotalCount, List<SmartCollectionViewModel> Page);
-}
+public record PagedSmartCollectionsViewModel(int TotalCount, List<SmartCollectionViewModel> Page);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/PagedTraktListsViewModel.cs b/ErsatzTV.Application/MediaCollections/PagedTraktListsViewModel.cs
index a0a3f0eb2..1ec2c7466 100644
--- a/ErsatzTV.Application/MediaCollections/PagedTraktListsViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/PagedTraktListsViewModel.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record PagedTraktListsViewModel(int TotalCount, List<TraktListViewModel> Page);
-}
+public record PagedTraktListsViewModel(int TotalCount, List<TraktListViewModel> Page);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetAllCollections.cs b/ErsatzTV.Application/MediaCollections/Queries/GetAllCollections.cs
index 92cbd8427..a3e0c132f 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetAllCollections.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetAllCollections.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetAllCollections : IRequest<List<MediaCollectionViewModel>>;
-}
+public record GetAllCollections : IRequest<List<MediaCollectionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetAllCollectionsHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetAllCollectionsHandler.cs
index 44b4b4f2d..31f586fe4 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetAllCollectionsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetAllCollectionsHandler.cs
@@ -1,30 +1,23 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetAllCollectionsHandler : IRequestHandler<GetAllCollections, List<MediaCollectionViewModel>>
 {
-    public class GetAllCollectionsHandler : IRequestHandler<GetAllCollections, List<MediaCollectionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<MediaCollectionViewModel>> Handle(
+        GetAllCollections request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<MediaCollectionViewModel>> Handle(
-            GetAllCollections request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Collections
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Collections
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollections.cs b/ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollections.cs
index 2492e9b53..ef22f393f 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollections.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollections.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetAllMultiCollections : IRequest<List<MultiCollectionViewModel>>;
-}
+public record GetAllMultiCollections : IRequest<List<MultiCollectionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollectionsHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollectionsHandler.cs
index 752712cf0..cf1982f66 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollectionsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetAllMultiCollectionsHandler.cs
@@ -1,30 +1,23 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetAllMultiCollectionsHandler : IRequestHandler<GetAllMultiCollections, List<MultiCollectionViewModel>>
 {
-    public class GetAllMultiCollectionsHandler : IRequestHandler<GetAllMultiCollections, List<MultiCollectionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllMultiCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<MultiCollectionViewModel>> Handle(
+        GetAllMultiCollections request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllMultiCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<MultiCollectionViewModel>> Handle(
-            GetAllMultiCollections request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.MultiCollections
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.MultiCollections
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollections.cs b/ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollections.cs
index 53b1ca9ac..147327ee3 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollections.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollections.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetAllSmartCollections : IRequest<List<SmartCollectionViewModel>>;
-}
+public record GetAllSmartCollections : IRequest<List<SmartCollectionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollectionsHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollectionsHandler.cs
index f6e3d11b0..2f3648b47 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollectionsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetAllSmartCollectionsHandler.cs
@@ -1,30 +1,23 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetAllSmartCollectionsHandler : IRequestHandler<GetAllSmartCollections, List<SmartCollectionViewModel>>
 {
-    public class GetAllSmartCollectionsHandler : IRequestHandler<GetAllSmartCollections, List<SmartCollectionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllSmartCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<SmartCollectionViewModel>> Handle(
+        GetAllSmartCollections request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllSmartCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<SmartCollectionViewModel>> Handle(
-            GetAllSmartCollections request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.SmartCollections
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.SmartCollections
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetCollectionById.cs b/ErsatzTV.Application/MediaCollections/Queries/GetCollectionById.cs
index 8d988eecd..71370776b 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetCollectionById.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetCollectionById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetCollectionById(int Id) : IRequest<Option<MediaCollectionViewModel>>;
-}
+public record GetCollectionById(int Id) : IRequest<Option<MediaCollectionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetCollectionByIdHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetCollectionByIdHandler.cs
index 4d7684d31..567841b94 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetCollectionByIdHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetCollectionByIdHandler.cs
@@ -1,30 +1,25 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetCollectionByIdHandler :
+    IRequestHandler<GetCollectionById, Option<MediaCollectionViewModel>>
 {
-    public class GetCollectionByIdHandler :
-        IRequestHandler<GetCollectionById, Option<MediaCollectionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetCollectionByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Option<MediaCollectionViewModel>> Handle(
+        GetCollectionById request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetCollectionByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Option<MediaCollectionViewModel>> Handle(
-            GetCollectionById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            return await dbContext.Collections
-                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
-                .MapT(ProjectToViewModel);
-        }
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.Collections
+            .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
+            .MapT(ProjectToViewModel);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionById.cs b/ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionById.cs
index d60dabcec..a98200ae5 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionById.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetMultiCollectionById(int Id) : IRequest<Option<MultiCollectionViewModel>>;
-}
+public record GetMultiCollectionById(int Id) : IRequest<Option<MultiCollectionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionByIdHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionByIdHandler.cs
index b56285db7..6aed14b61 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionByIdHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetMultiCollectionByIdHandler.cs
@@ -1,33 +1,28 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetMultiCollectionByIdHandler : IRequestHandler<GetMultiCollectionById, Option<MultiCollectionViewModel>>
 {
-    public class GetMultiCollectionByIdHandler : IRequestHandler<GetMultiCollectionById, Option<MultiCollectionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetMultiCollectionByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Option<MultiCollectionViewModel>> Handle(
+        GetMultiCollectionById request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetMultiCollectionByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Option<MultiCollectionViewModel>> Handle(
-            GetMultiCollectionById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.MultiCollections
-                .Include(mc => mc.MultiCollectionItems)
-                .ThenInclude(mc => mc.Collection)
-                .Include(mc => mc.MultiCollectionSmartItems)
-                .ThenInclude(mc => mc.SmartCollection)
-                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
-                .MapT(ProjectToViewModel);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.MultiCollections
+            .Include(mc => mc.MultiCollectionItems)
+            .ThenInclude(mc => mc.Collection)
+            .Include(mc => mc.MultiCollectionSmartItems)
+            .ThenInclude(mc => mc.SmartCollection)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
+            .MapT(ProjectToViewModel);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetPagedCollections.cs b/ErsatzTV.Application/MediaCollections/Queries/GetPagedCollections.cs
index 45dded975..f90fdf714 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedCollections.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedCollections.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetPagedCollections(int PageNum, int PageSize) : IRequest<PagedMediaCollectionsViewModel>;
-}
+public record GetPagedCollections(int PageNum, int PageSize) : IRequest<PagedMediaCollectionsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetPagedCollectionsHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetPagedCollectionsHandler.cs
index b002284b9..1d361a0aa 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedCollectionsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedCollectionsHandler.cs
@@ -1,46 +1,39 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetPagedCollectionsHandler : IRequestHandler<GetPagedCollections, PagedMediaCollectionsViewModel>
 {
-    public class GetPagedCollectionsHandler : IRequestHandler<GetPagedCollections, PagedMediaCollectionsViewModel>
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetPagedCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public GetPagedCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<PagedMediaCollectionsViewModel> Handle(
+        GetPagedCollections request,
+        CancellationToken cancellationToken)
+    {
+        int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM Collection");
 
-        public async Task<PagedMediaCollectionsViewModel> Handle(
-            GetPagedCollections request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM Collection");
-
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<MediaCollectionViewModel> page = await dbContext.Collections.FromSqlRaw(
-                    @"SELECT * FROM Collection
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<MediaCollectionViewModel> page = await dbContext.Collections.FromSqlRaw(
+                @"SELECT * FROM Collection
                     ORDER BY Name
                     COLLATE NOCASE
                     LIMIT {0} OFFSET {1}",
-                    request.PageSize,
-                    request.PageNum * request.PageSize)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+                request.PageSize,
+                request.PageNum * request.PageSize)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 
-            return new PagedMediaCollectionsViewModel(count, page);
-        }
+        return new PagedMediaCollectionsViewModel(count, page);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollections.cs b/ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollections.cs
index f000d06b5..cb91f8489 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollections.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollections.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetPagedMultiCollections(int PageNum, int PageSize) : IRequest<PagedMultiCollectionsViewModel>;
-}
+public record GetPagedMultiCollections(int PageNum, int PageSize) : IRequest<PagedMultiCollectionsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollectionsHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollectionsHandler.cs
index 51dde5d88..b1534c999 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollectionsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedMultiCollectionsHandler.cs
@@ -1,48 +1,41 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetPagedMultiCollectionsHandler : IRequestHandler<GetPagedMultiCollections, PagedMultiCollectionsViewModel>
 {
-    public class GetPagedMultiCollectionsHandler : IRequestHandler<GetPagedMultiCollections, PagedMultiCollectionsViewModel>
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetPagedMultiCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public GetPagedMultiCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<PagedMultiCollectionsViewModel> Handle(
+        GetPagedMultiCollections request,
+        CancellationToken cancellationToken)
+    {
+        int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM MultiCollection");
 
-        public async Task<PagedMultiCollectionsViewModel> Handle(
-            GetPagedMultiCollections request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM MultiCollection");
-
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<MultiCollectionViewModel> page = await dbContext.MultiCollections.FromSqlRaw(
-                    @"SELECT * FROM MultiCollection
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<MultiCollectionViewModel> page = await dbContext.MultiCollections.FromSqlRaw(
+                @"SELECT * FROM MultiCollection
                     ORDER BY Name
                     COLLATE NOCASE
                     LIMIT {0} OFFSET {1}",
-                    request.PageSize,
-                    request.PageNum * request.PageSize)
-                .Include(mc => mc.MultiCollectionItems)
-                .ThenInclude(i => i.Collection)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+                request.PageSize,
+                request.PageNum * request.PageSize)
+            .Include(mc => mc.MultiCollectionItems)
+            .ThenInclude(i => i.Collection)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 
-            return new PagedMultiCollectionsViewModel(count, page);
-        }
+        return new PagedMultiCollectionsViewModel(count, page);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollections.cs b/ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollections.cs
index 7fa74cfcd..c0a1849b9 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollections.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollections.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetPagedSmartCollections(int PageNum, int PageSize) : IRequest<PagedSmartCollectionsViewModel>;
-}
+public record GetPagedSmartCollections(int PageNum, int PageSize) : IRequest<PagedSmartCollectionsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollectionsHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollectionsHandler.cs
index fc42a61c9..a4915be00 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollectionsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedSmartCollectionsHandler.cs
@@ -1,46 +1,39 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetPagedSmartCollectionsHandler : IRequestHandler<GetPagedSmartCollections, PagedSmartCollectionsViewModel>
 {
-    public class GetPagedSmartCollectionsHandler : IRequestHandler<GetPagedSmartCollections, PagedSmartCollectionsViewModel>
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetPagedSmartCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public GetPagedSmartCollectionsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<PagedSmartCollectionsViewModel> Handle(
+        GetPagedSmartCollections request,
+        CancellationToken cancellationToken)
+    {
+        int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM SmartCollection");
 
-        public async Task<PagedSmartCollectionsViewModel> Handle(
-            GetPagedSmartCollections request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM SmartCollection");
-
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<SmartCollectionViewModel> page = await dbContext.SmartCollections.FromSqlRaw(
-                    @"SELECT * FROM SmartCollection
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<SmartCollectionViewModel> page = await dbContext.SmartCollections.FromSqlRaw(
+                @"SELECT * FROM SmartCollection
                     ORDER BY Name
                     COLLATE NOCASE
                     LIMIT {0} OFFSET {1}",
-                    request.PageSize,
-                    request.PageNum * request.PageSize)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+                request.PageSize,
+                request.PageNum * request.PageSize)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 
-            return new PagedSmartCollectionsViewModel(count, page);
-        }
+        return new PagedSmartCollectionsViewModel(count, page);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktLists.cs b/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktLists.cs
index 5f28b1efc..e6771f0c4 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktLists.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktLists.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.MediaCollections;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
-{
-    public record GetPagedTraktLists(int PageNum, int PageSize) : IRequest<PagedTraktListsViewModel>;
-}
+public record GetPagedTraktLists(int PageNum, int PageSize) : IRequest<PagedTraktListsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktListsHandler.cs b/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktListsHandler.cs
index 88624dff7..826e13665 100644
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktListsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktListsHandler.cs
@@ -1,47 +1,40 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.MediaCollections.Mapper;
 
-namespace ErsatzTV.Application.MediaCollections.Queries
+namespace ErsatzTV.Application.MediaCollections;
+
+public class GetPagedTraktListsHandler : IRequestHandler<GetPagedTraktLists, PagedTraktListsViewModel>
 {
-    public class GetPagedTraktListsHandler : IRequestHandler<GetPagedTraktLists, PagedTraktListsViewModel>
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetPagedTraktListsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public GetPagedTraktListsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<PagedTraktListsViewModel> Handle(
+        GetPagedTraktLists request,
+        CancellationToken cancellationToken)
+    {
+        int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM TraktList");
 
-        public async Task<PagedTraktListsViewModel> Handle(
-            GetPagedTraktLists request,
-            CancellationToken cancellationToken)
-        {
-            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM TraktList");
-
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<TraktListViewModel> page = await dbContext.TraktLists.FromSqlRaw(
-                    @"SELECT * FROM TraktList
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<TraktListViewModel> page = await dbContext.TraktLists.FromSqlRaw(
+                @"SELECT * FROM TraktList
                     ORDER BY Name
                     COLLATE NOCASE
                     LIMIT {0} OFFSET {1}",
-                    request.PageSize,
-                    request.PageNum * request.PageSize)
-                .Include(l => l.Items)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+                request.PageSize,
+                request.PageNum * request.PageSize)
+            .Include(l => l.Items)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 
-            return new PagedTraktListsViewModel(count, page);
-        }
+        return new PagedTraktListsViewModel(count, page);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/SmartCollectionViewModel.cs b/ErsatzTV.Application/MediaCollections/SmartCollectionViewModel.cs
index 07d032251..487ca1be5 100644
--- a/ErsatzTV.Application/MediaCollections/SmartCollectionViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/SmartCollectionViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record SmartCollectionViewModel(int Id, string Name, string Query);
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record SmartCollectionViewModel(int Id, string Name, string Query);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaCollections/TraktListViewModel.cs b/ErsatzTV.Application/MediaCollections/TraktListViewModel.cs
index 9c96c1009..2c5be7ab6 100644
--- a/ErsatzTV.Application/MediaCollections/TraktListViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/TraktListViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.MediaCollections
-{
-    public record TraktListViewModel(int Id, int TraktId, string Slug, string Name, int ItemCount, int MatchCount);
-}
+namespace ErsatzTV.Application.MediaCollections;
+
+public record TraktListViewModel(int Id, int TraktId, string Slug, string Name, int ItemCount, int MatchCount);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaItems/Mapper.cs b/ErsatzTV.Application/MediaItems/Mapper.cs
index 364631feb..5bd82a910 100644
--- a/ErsatzTV.Application/MediaItems/Mapper.cs
+++ b/ErsatzTV.Application/MediaItems/Mapper.cs
@@ -1,22 +1,21 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.MediaItems
+namespace ErsatzTV.Application.MediaItems;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static NamedMediaItemViewModel ProjectToViewModel(Show show) =>
-            new(show.Id, show.ShowMetadata.HeadOrNone().Map(sm => $"{sm?.Title} ({sm?.Year})").IfNone("???"));
+    internal static NamedMediaItemViewModel ProjectToViewModel(Show show) =>
+        new(show.Id, show.ShowMetadata.HeadOrNone().Map(sm => $"{sm?.Title} ({sm?.Year})").IfNone("???"));
 
-        internal static NamedMediaItemViewModel ProjectToViewModel(Season season) =>
-            new(season.Id, $"{ShowTitle(season)} ({SeasonDescription(season)})");
+    internal static NamedMediaItemViewModel ProjectToViewModel(Season season) =>
+        new(season.Id, $"{ShowTitle(season)} ({SeasonDescription(season)})");
 
-        internal static NamedMediaItemViewModel ProjectToViewModel(Artist artist) =>
-            new(artist.Id, artist.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => "???"));
+    internal static NamedMediaItemViewModel ProjectToViewModel(Artist artist) =>
+        new(artist.Id, artist.ArtistMetadata.HeadOrNone().Match(am => am.Title, () => "???"));
 
-        private static string ShowTitle(Season season) =>
-            season.Show.ShowMetadata.HeadOrNone().Map(sm => sm.Title).IfNone("???");
+    private static string ShowTitle(Season season) =>
+        season.Show.ShowMetadata.HeadOrNone().Map(sm => sm.Title).IfNone("???");
 
-        private static string SeasonDescription(Season season) =>
-            season.SeasonNumber == 0 ? "Specials" : $"Season {season.SeasonNumber}";
-    }
-}
+    private static string SeasonDescription(Season season) =>
+        season.SeasonNumber == 0 ? "Specials" : $"Season {season.SeasonNumber}";
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaItems/NamedMediaItemViewModel.cs b/ErsatzTV.Application/MediaItems/NamedMediaItemViewModel.cs
index 8af3f337a..af889ae8a 100644
--- a/ErsatzTV.Application/MediaItems/NamedMediaItemViewModel.cs
+++ b/ErsatzTV.Application/MediaItems/NamedMediaItemViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.MediaItems
-{
-    public record NamedMediaItemViewModel(int MediaItemId, string Name);
-}
+namespace ErsatzTV.Application.MediaItems;
+
+public record NamedMediaItemViewModel(int MediaItemId, string Name);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodes.cs b/ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodes.cs
index c9145ea10..f0edf0e64 100644
--- a/ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodes.cs
+++ b/ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodes.cs
@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using System.Globalization;
-using MediatR;
+using System.Globalization;
 
-namespace ErsatzTV.Application.MediaItems.Queries
-{
-    public record GetAllLanguageCodes : IRequest<List<CultureInfo>>;
-}
+namespace ErsatzTV.Application.MediaItems;
+
+public record GetAllLanguageCodes : IRequest<List<CultureInfo>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodesHandler.cs b/ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodesHandler.cs
index 275f53ff3..ea37fdd1e 100644
--- a/ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodesHandler.cs
+++ b/ErsatzTV.Application/MediaItems/Queries/GetAllLanguageCodesHandler.cs
@@ -1,53 +1,45 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Globalization;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.MediaItems.Queries
+namespace ErsatzTV.Application.MediaItems;
+
+public class GetAllLanguageCodesHandler : IRequestHandler<GetAllLanguageCodes, List<CultureInfo>>
 {
-    public class GetAllLanguageCodesHandler : IRequestHandler<GetAllLanguageCodes, List<CultureInfo>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMediaItemRepository _mediaItemRepository;
+
+    public GetAllLanguageCodesHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMediaItemRepository mediaItemRepository)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMediaItemRepository _mediaItemRepository;
+        _dbContextFactory = dbContextFactory;
+        _mediaItemRepository = mediaItemRepository;
+    }
 
-        public GetAllLanguageCodesHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMediaItemRepository mediaItemRepository)
-        {
-            _dbContextFactory = dbContextFactory;
-            _mediaItemRepository = mediaItemRepository;
-        }
-
-        public async Task<List<CultureInfo>> Handle(GetAllLanguageCodes request, CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+    public async Task<List<CultureInfo>> Handle(GetAllLanguageCodes request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             
-            var result = new System.Collections.Generic.HashSet<CultureInfo>();
+        var result = new System.Collections.Generic.HashSet<CultureInfo>();
 
-            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
-            List<string> mediaCodes = await _mediaItemRepository.GetAllLanguageCodes();
-            foreach (string mediaCode in mediaCodes)
+        CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+        List<string> mediaCodes = await _mediaItemRepository.GetAllLanguageCodes();
+        foreach (string mediaCode in mediaCodes)
+        {
+            foreach (string code in await dbContext.LanguageCodes.GetAllLanguageCodes(mediaCode))
             {
-                foreach (string code in await dbContext.LanguageCodes.GetAllLanguageCodes(mediaCode))
+                Option<CultureInfo> maybeCulture = allCultures.Find(
+                    c => string.Equals(code, c.ThreeLetterISOLanguageName, StringComparison.OrdinalIgnoreCase));
+                foreach (CultureInfo culture in maybeCulture)
                 {
-                    Option<CultureInfo> maybeCulture = allCultures.Find(
-                        c => string.Equals(code, c.ThreeLetterISOLanguageName, StringComparison.OrdinalIgnoreCase));
-                    foreach (CultureInfo culture in maybeCulture)
-                    {
-                        result.Add(culture);
-                    }
+                    result.Add(culture);
                 }
             }
-
-            return result.ToList();
         }
+
+        return result.ToList();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibrary.cs b/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibrary.cs
index da4999e12..74faa99ae 100644
--- a/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibrary.cs
+++ b/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibrary.cs
@@ -1,22 +1,19 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.MediaSources.Commands
+namespace ErsatzTV.Application.MediaSources;
+
+public interface IScanLocalLibrary : IRequest<Either<BaseError, string>>, IBackgroundServiceRequest
 {
-    public interface IScanLocalLibrary : IRequest<Either<BaseError, string>>, IBackgroundServiceRequest
-    {
-        int LibraryId { get; }
-        bool ForceScan { get; }
-    }
-
-    public record ScanLocalLibraryIfNeeded(int LibraryId) : IScanLocalLibrary
-    {
-        public bool ForceScan => false;
-    }
-
-    public record ForceScanLocalLibrary(int LibraryId) : IScanLocalLibrary
-    {
-        public bool ForceScan => true;
-    }
+    int LibraryId { get; }
+    bool ForceScan { get; }
 }
+
+public record ScanLocalLibraryIfNeeded(int LibraryId) : IScanLocalLibrary
+{
+    public bool ForceScan => false;
+}
+
+public record ForceScanLocalLibrary(int LibraryId) : IScanLocalLibrary
+{
+    public bool ForceScan => true;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs b/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
index 57dd9b6f1..64b21dcb0 100644
--- a/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
@@ -1,226 +1,218 @@
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.MediaSources.Commands
+namespace ErsatzTV.Application.MediaSources;
+
+public class ScanLocalLibraryHandler : IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>,
+    IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>
 {
-    public class ScanLocalLibraryHandler : IRequestHandler<ForceScanLocalLibrary, Either<BaseError, string>>,
-        IRequestHandler<ScanLocalLibraryIfNeeded, Either<BaseError, string>>
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly IEntityLocker _entityLocker;
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILogger<ScanLocalLibraryHandler> _logger;
+    private readonly IMediator _mediator;
+    private readonly IMovieFolderScanner _movieFolderScanner;
+    private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
+    private readonly IOtherVideoFolderScanner _otherVideoFolderScanner;
+    private readonly ISongFolderScanner _songFolderScanner;
+    private readonly ITelevisionFolderScanner _televisionFolderScanner;
+
+    public ScanLocalLibraryHandler(
+        ILibraryRepository libraryRepository,
+        IConfigElementRepository configElementRepository,
+        IMovieFolderScanner movieFolderScanner,
+        ITelevisionFolderScanner televisionFolderScanner,
+        IMusicVideoFolderScanner musicVideoFolderScanner,
+        IOtherVideoFolderScanner otherVideoFolderScanner,
+        ISongFolderScanner songFolderScanner,
+        IEntityLocker entityLocker,
+        IMediator mediator,
+        ILogger<ScanLocalLibraryHandler> logger)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly IEntityLocker _entityLocker;
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILogger<ScanLocalLibraryHandler> _logger;
-        private readonly IMediator _mediator;
-        private readonly IMovieFolderScanner _movieFolderScanner;
-        private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
-        private readonly IOtherVideoFolderScanner _otherVideoFolderScanner;
-        private readonly ISongFolderScanner _songFolderScanner;
-        private readonly ITelevisionFolderScanner _televisionFolderScanner;
+        _libraryRepository = libraryRepository;
+        _configElementRepository = configElementRepository;
+        _movieFolderScanner = movieFolderScanner;
+        _televisionFolderScanner = televisionFolderScanner;
+        _musicVideoFolderScanner = musicVideoFolderScanner;
+        _otherVideoFolderScanner = otherVideoFolderScanner;
+        _songFolderScanner = songFolderScanner;
+        _entityLocker = entityLocker;
+        _mediator = mediator;
+        _logger = logger;
+    }
 
-        public ScanLocalLibraryHandler(
-            ILibraryRepository libraryRepository,
-            IConfigElementRepository configElementRepository,
-            IMovieFolderScanner movieFolderScanner,
-            ITelevisionFolderScanner televisionFolderScanner,
-            IMusicVideoFolderScanner musicVideoFolderScanner,
-            IOtherVideoFolderScanner otherVideoFolderScanner,
-            ISongFolderScanner songFolderScanner,
-            IEntityLocker entityLocker,
-            IMediator mediator,
-            ILogger<ScanLocalLibraryHandler> logger)
+    public Task<Either<BaseError, string>> Handle(
+        ForceScanLocalLibrary request,
+        CancellationToken cancellationToken) => Handle(request);
+
+    public Task<Either<BaseError, string>> Handle(
+        ScanLocalLibraryIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request);
+
+    private Task<Either<BaseError, string>>
+        Handle(IScanLocalLibrary request) =>
+        Validate(request)
+            .MapT(parameters => PerformScan(parameters).Map(_ => parameters.LocalLibrary.Name))
+            .Bind(v => v.ToEitherAsync());
+
+    private async Task<Unit> PerformScan(RequestParameters parameters)
+    {
+        (LocalLibrary localLibrary, string ffprobePath, string ffmpegPath, bool forceScan,
+            int libraryRefreshInterval) = parameters;
+
+        var sw = new Stopwatch();
+        sw.Start();
+
+        var scanned = false;
+
+        for (var i = 0; i < localLibrary.Paths.Count; i++)
         {
-            _libraryRepository = libraryRepository;
-            _configElementRepository = configElementRepository;
-            _movieFolderScanner = movieFolderScanner;
-            _televisionFolderScanner = televisionFolderScanner;
-            _musicVideoFolderScanner = musicVideoFolderScanner;
-            _otherVideoFolderScanner = otherVideoFolderScanner;
-            _songFolderScanner = songFolderScanner;
-            _entityLocker = entityLocker;
-            _mediator = mediator;
-            _logger = logger;
-        }
+            LibraryPath libraryPath = localLibrary.Paths[i];
 
-        public Task<Either<BaseError, string>> Handle(
-            ForceScanLocalLibrary request,
-            CancellationToken cancellationToken) => Handle(request);
+            decimal progressMin = (decimal) i / localLibrary.Paths.Count;
+            decimal progressMax = (decimal) (i + 1) / localLibrary.Paths.Count;
 
-        public Task<Either<BaseError, string>> Handle(
-            ScanLocalLibraryIfNeeded request,
-            CancellationToken cancellationToken) => Handle(request);
-
-        private Task<Either<BaseError, string>>
-            Handle(IScanLocalLibrary request) =>
-            Validate(request)
-                .MapT(parameters => PerformScan(parameters).Map(_ => parameters.LocalLibrary.Name))
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<Unit> PerformScan(RequestParameters parameters)
-        {
-            (LocalLibrary localLibrary, string ffprobePath, string ffmpegPath, bool forceScan,
-                int libraryRefreshInterval) = parameters;
-
-            var sw = new Stopwatch();
-            sw.Start();
-
-            var scanned = false;
-
-            for (var i = 0; i < localLibrary.Paths.Count; i++)
+            var lastScan = new DateTimeOffset(libraryPath.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
+            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
+            if (forceScan || nextScan < DateTimeOffset.Now)
             {
-                LibraryPath libraryPath = localLibrary.Paths[i];
+                scanned = true;
 
-                decimal progressMin = (decimal) i / localLibrary.Paths.Count;
-                decimal progressMax = (decimal) (i + 1) / localLibrary.Paths.Count;
-
-                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
-                DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
-                if (forceScan || nextScan < DateTimeOffset.Now)
+                switch (localLibrary.MediaKind)
                 {
-                    scanned = true;
-
-                    switch (localLibrary.MediaKind)
-                    {
-                        case LibraryMediaKind.Movies:
-                            await _movieFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax);
-                            break;
-                        case LibraryMediaKind.Shows:
-                            await _televisionFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax);
-                            break;
-                        case LibraryMediaKind.MusicVideos:
-                            await _musicVideoFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax);
-                            break;
-                        case LibraryMediaKind.OtherVideos:
-                            await _otherVideoFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffprobePath,
-                                progressMin,
-                                progressMax);
-                            break;
-                        case LibraryMediaKind.Songs:
-                            await _songFolderScanner.ScanFolder(
-                                libraryPath,
-                                ffprobePath,
-                                ffmpegPath,
-                                progressMin,
-                                progressMax);
-                            break;
-                    }
-
-                    libraryPath.LastScan = DateTime.UtcNow;
-                    await _libraryRepository.UpdateLastScan(libraryPath);
-                }
-
-                await _mediator.Publish(new LibraryScanProgress(libraryPath.LibraryId, progressMax));
-            }
-
-            sw.Stop();
-
-            if (scanned)
-            {
-                _logger.LogDebug(
-                    "Scan of library {Name} completed in {Duration}",
-                    localLibrary.Name,
-                    TimeSpan.FromMilliseconds(sw.ElapsedMilliseconds));
-            }
-            else
-            {
-                _logger.LogDebug(
-                    "Skipping unforced scan of local media library {Name}",
-                    localLibrary.Name);
-            }
-
-            await _mediator.Publish(new LibraryScanProgress(localLibrary.Id, 0));
-
-            _entityLocker.UnlockLibrary(localLibrary.Id);
-            return Unit.Default;
-        }
-
-        private async Task<Validation<BaseError, RequestParameters>> Validate(IScanLocalLibrary request)
-        {
-            Validation<BaseError, LocalLibrary> libraryResult = await LocalLibraryMustExist(request);
-            Validation<BaseError, string> ffprobePathResult = await ValidateFFprobePath();
-            Validation<BaseError, string> ffmpegPathResult = await ValidateFFmpegPath();
-            Validation<BaseError, int> refreshIntervalResult = await ValidateLibraryRefreshInterval();
-
-            try
-            {
-                return (libraryResult, ffprobePathResult, ffmpegPathResult, refreshIntervalResult)
-                    .Apply(
-                        (library, ffprobePath, ffmpegPath, libraryRefreshInterval) => new RequestParameters(
-                            library,
+                    case LibraryMediaKind.Movies:
+                        await _movieFolderScanner.ScanFolder(
+                            libraryPath,
+                            ffprobePath,
+                            progressMin,
+                            progressMax);
+                        break;
+                    case LibraryMediaKind.Shows:
+                        await _televisionFolderScanner.ScanFolder(
+                            libraryPath,
+                            ffprobePath,
+                            progressMin,
+                            progressMax);
+                        break;
+                    case LibraryMediaKind.MusicVideos:
+                        await _musicVideoFolderScanner.ScanFolder(
+                            libraryPath,
+                            ffprobePath,
+                            progressMin,
+                            progressMax);
+                        break;
+                    case LibraryMediaKind.OtherVideos:
+                        await _otherVideoFolderScanner.ScanFolder(
+                            libraryPath,
+                            ffprobePath,
+                            progressMin,
+                            progressMax);
+                        break;
+                    case LibraryMediaKind.Songs:
+                        await _songFolderScanner.ScanFolder(
+                            libraryPath,
                             ffprobePath,
                             ffmpegPath,
-                            request.ForceScan,
-                            libraryRefreshInterval));
+                            progressMin,
+                            progressMax);
+                        break;
+                }
+
+                libraryPath.LastScan = DateTime.UtcNow;
+                await _libraryRepository.UpdateLastScan(libraryPath);
             }
-            finally
+
+            await _mediator.Publish(new LibraryScanProgress(libraryPath.LibraryId, progressMax));
+        }
+
+        sw.Stop();
+
+        if (scanned)
+        {
+            _logger.LogDebug(
+                "Scan of library {Name} completed in {Duration}",
+                localLibrary.Name,
+                TimeSpan.FromMilliseconds(sw.ElapsedMilliseconds));
+        }
+        else
+        {
+            _logger.LogDebug(
+                "Skipping unforced scan of local media library {Name}",
+                localLibrary.Name);
+        }
+
+        await _mediator.Publish(new LibraryScanProgress(localLibrary.Id, 0));
+
+        _entityLocker.UnlockLibrary(localLibrary.Id);
+        return Unit.Default;
+    }
+
+    private async Task<Validation<BaseError, RequestParameters>> Validate(IScanLocalLibrary request)
+    {
+        Validation<BaseError, LocalLibrary> libraryResult = await LocalLibraryMustExist(request);
+        Validation<BaseError, string> ffprobePathResult = await ValidateFFprobePath();
+        Validation<BaseError, string> ffmpegPathResult = await ValidateFFmpegPath();
+        Validation<BaseError, int> refreshIntervalResult = await ValidateLibraryRefreshInterval();
+
+        try
+        {
+            return (libraryResult, ffprobePathResult, ffmpegPathResult, refreshIntervalResult)
+                .Apply(
+                    (library, ffprobePath, ffmpegPath, libraryRefreshInterval) => new RequestParameters(
+                        library,
+                        ffprobePath,
+                        ffmpegPath,
+                        request.ForceScan,
+                        libraryRefreshInterval));
+        }
+        finally
+        {
+            // ensure we unlock the library if any validation is unsuccessful
+            foreach (LocalLibrary library in libraryResult.SuccessToSeq())
             {
-                // ensure we unlock the library if any validation is unsuccessful
-                foreach (LocalLibrary library in libraryResult.SuccessToSeq())
+                if (ffprobePathResult.IsFail || ffmpegPathResult.IsFail || refreshIntervalResult.IsFail)
                 {
-                    if (ffprobePathResult.IsFail || ffmpegPathResult.IsFail || refreshIntervalResult.IsFail)
-                    {
-                        _entityLocker.UnlockLibrary(library.Id);
-                    }
+                    _entityLocker.UnlockLibrary(library.Id);
                 }
             }
         }
-
-        private Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
-            IScanLocalLibrary request) =>
-            _libraryRepository.Get(request.LibraryId)
-                .Map(maybeLibrary => maybeLibrary.Map(ms => ms as LocalLibrary))
-                .Map(v => v.ToValidation<BaseError>($"Local library {request.LibraryId} does not exist."));
-
-        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
-            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
-                .FilterT(File.Exists)
-                .Map(
-                    ffprobePath =>
-                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
-
-        private Task<Validation<BaseError, string>> ValidateFFmpegPath() =>
-            _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath)
-                .FilterT(File.Exists)
-                .Map(
-                    ffmpegPath =>
-                        ffmpegPath.ToValidation<BaseError>("FFmpeg path does not exist on the file system"));
-
-        private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
-            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
-                .FilterT(lri => lri > 0)
-                .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
-
-        private record RequestParameters(
-            LocalLibrary LocalLibrary,
-            string FFprobePath,
-            string FFmpegPath,
-            bool ForceScan,
-            int LibraryRefreshInterval);
     }
-}
+
+    private Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
+        IScanLocalLibrary request) =>
+        _libraryRepository.Get(request.LibraryId)
+            .Map(maybeLibrary => maybeLibrary.Map(ms => ms as LocalLibrary))
+            .Map(v => v.ToValidation<BaseError>($"Local library {request.LibraryId} does not exist."));
+
+    private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
+        _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
+            .FilterT(File.Exists)
+            .Map(
+                ffprobePath =>
+                    ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
+
+    private Task<Validation<BaseError, string>> ValidateFFmpegPath() =>
+        _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath)
+            .FilterT(File.Exists)
+            .Map(
+                ffmpegPath =>
+                    ffmpegPath.ToValidation<BaseError>("FFmpeg path does not exist on the file system"));
+
+    private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
+        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+            .FilterT(lri => lri > 0)
+            .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
+
+    private record RequestParameters(
+        LocalLibrary LocalLibrary,
+        string FFprobePath,
+        string FFmpegPath,
+        bool ForceScan,
+        int LibraryRefreshInterval);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaSources/LocalMediaSourceViewModel.cs b/ErsatzTV.Application/MediaSources/LocalMediaSourceViewModel.cs
index 96111acf5..90d012b27 100644
--- a/ErsatzTV.Application/MediaSources/LocalMediaSourceViewModel.cs
+++ b/ErsatzTV.Application/MediaSources/LocalMediaSourceViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.MediaSources
-{
-    public record LocalMediaSourceViewModel(int Id) : MediaSourceViewModel(Id, "Local");
-}
+namespace ErsatzTV.Application.MediaSources;
+
+public record LocalMediaSourceViewModel(int Id) : MediaSourceViewModel(Id, "Local");
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaSources/MediaSourceViewModel.cs b/ErsatzTV.Application/MediaSources/MediaSourceViewModel.cs
index 036a23d78..bb829f5a0 100644
--- a/ErsatzTV.Application/MediaSources/MediaSourceViewModel.cs
+++ b/ErsatzTV.Application/MediaSources/MediaSourceViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.MediaSources
-{
-    public record MediaSourceViewModel(int Id, string Name);
-}
+namespace ErsatzTV.Application.MediaSources;
+
+public record MediaSourceViewModel(int Id, string Name);
\ No newline at end of file
diff --git a/ErsatzTV.Application/MediaSources/RemoteMediaSourceViewModel.cs b/ErsatzTV.Application/MediaSources/RemoteMediaSourceViewModel.cs
index 7ae53a49f..0b00f2aee 100644
--- a/ErsatzTV.Application/MediaSources/RemoteMediaSourceViewModel.cs
+++ b/ErsatzTV.Application/MediaSources/RemoteMediaSourceViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.MediaSources
-{
-    public record RemoteMediaSourceViewModel(int Id, string Name, string Address) : MediaSourceViewModel(Id, Name);
-}
+namespace ErsatzTV.Application.MediaSources;
+
+public record RemoteMediaSourceViewModel(int Id, string Name, string Address) : MediaSourceViewModel(Id, Name);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Movies/Mapper.cs b/ErsatzTV.Application/Movies/Mapper.cs
index 2f954ad33..f958ae562 100644
--- a/ErsatzTV.Application/Movies/Mapper.cs
+++ b/ErsatzTV.Application/Movies/Mapper.cs
@@ -1,94 +1,88 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Jellyfin;
 using Flurl;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Movies
+namespace ErsatzTV.Application.Movies;
+
+internal static class Mapper
 {
-    internal static class Mapper
+    internal static MovieViewModel ProjectToViewModel(
+        Movie movie,
+        List<string> languageCodes,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby)
     {
-        internal static MovieViewModel ProjectToViewModel(
-            Movie movie,
-            List<string> languageCodes,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby)
+        MovieMetadata metadata = Optional(movie.MovieMetadata).Flatten().Head();
+        return new MovieViewModel(
+            metadata.Title,
+            metadata.Year?.ToString(),
+            metadata.Plot,
+            metadata.Genres.Map(g => g.Name).ToList(),
+            metadata.Tags.Map(t => t.Name).ToList(),
+            metadata.Studios.Map(s => s.Name).ToList(),
+            (metadata.ContentRating ?? string.Empty).Split("/").Map(s => s.Trim())
+            .Where(x => !string.IsNullOrWhiteSpace(x)).ToList(),
+            LanguagesForMovie(languageCodes),
+            metadata.Actors.OrderBy(a => a.Order).ThenBy(a => a.Id)
+                .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin, maybeEmby))
+                .ToList(),
+            metadata.Directors.Map(d => d.Name).ToList(),
+            metadata.Writers.Map(w => w.Name).ToList(),
+            movie.GetHeadVersion().MediaFiles.Head().Path,
+            movie.State)
         {
-            MovieMetadata metadata = Optional(movie.MovieMetadata).Flatten().Head();
-            return new MovieViewModel(
-                metadata.Title,
-                metadata.Year?.ToString(),
-                metadata.Plot,
-                metadata.Genres.Map(g => g.Name).ToList(),
-                metadata.Tags.Map(t => t.Name).ToList(),
-                metadata.Studios.Map(s => s.Name).ToList(),
-                (metadata.ContentRating ?? string.Empty).Split("/").Map(s => s.Trim())
-                .Where(x => !string.IsNullOrWhiteSpace(x)).ToList(),
-                LanguagesForMovie(languageCodes),
-                metadata.Actors.OrderBy(a => a.Order).ThenBy(a => a.Id)
-                    .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin, maybeEmby))
-                    .ToList(),
-                metadata.Directors.Map(d => d.Name).ToList(),
-                metadata.Writers.Map(w => w.Name).ToList(),
-                movie.GetHeadVersion().MediaFiles.Head().Path,
-                movie.State)
-            {
-                Poster = Artwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby),
-                FanArt = Artwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby)
-            };
-        }
-
-        private static List<CultureInfo> LanguagesForMovie(List<string> languageCodes)
-        {
-            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
-
-            return languageCodes
-                .Distinct()
-                .Map(
-                    lang => allCultures.Filter(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
-                .Sequence()
-                .Flatten()
-                .ToList();
-        }
-
-        private static string Artwork(
-            Metadata metadata,
-            ArtworkKind artworkKind,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby)
-        {
-            string artwork = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
-                .Match(a => a.Path, string.Empty);
-
-            if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
-            {
-                Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
-                if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
-                {
-                    url.SetQueryParam("fillHeight", 440);
-                }
-
-                artwork = url;
-            }
-            else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
-            {
-                Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
-                if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
-                {
-                    url.SetQueryParam("maxHeight", 440);
-                }
-
-                artwork = url;
-            }
-
-            return artwork;
-        }
+            Poster = Artwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby),
+            FanArt = Artwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby)
+        };
     }
-}
+
+    private static List<CultureInfo> LanguagesForMovie(List<string> languageCodes)
+    {
+        CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+
+        return languageCodes
+            .Distinct()
+            .Map(
+                lang => allCultures.Filter(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+            .Sequence()
+            .Flatten()
+            .ToList();
+    }
+
+    private static string Artwork(
+        Metadata metadata,
+        ArtworkKind artworkKind,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby)
+    {
+        string artwork = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
+            .Match(a => a.Path, string.Empty);
+
+        if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
+        {
+            Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
+            if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
+            {
+                url.SetQueryParam("fillHeight", 440);
+            }
+
+            artwork = url;
+        }
+        else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
+        {
+            Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
+            if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
+            {
+                url.SetQueryParam("maxHeight", 440);
+            }
+
+            artwork = url;
+        }
+
+        return artwork;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Movies/MovieViewModel.cs b/ErsatzTV.Application/Movies/MovieViewModel.cs
index 65750eccc..6c63f61d7 100644
--- a/ErsatzTV.Application/Movies/MovieViewModel.cs
+++ b/ErsatzTV.Application/Movies/MovieViewModel.cs
@@ -1,26 +1,24 @@
-using System.Collections.Generic;
-using System.Globalization;
+using System.Globalization;
 using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Movies
+namespace ErsatzTV.Application.Movies;
+
+public record MovieViewModel(
+    string Title,
+    string Year,
+    string Plot,
+    List<string> Genres,
+    List<string> Tags,
+    List<string> Studios,
+    List<string> ContentRatings,
+    List<CultureInfo> Languages,
+    List<ActorCardViewModel> Actors,
+    List<string> Directors,
+    List<string> Writers,
+    string Path,
+    MediaItemState MediaItemState)
 {
-    public record MovieViewModel(
-        string Title,
-        string Year,
-        string Plot,
-        List<string> Genres,
-        List<string> Tags,
-        List<string> Studios,
-        List<string> ContentRatings,
-        List<CultureInfo> Languages,
-        List<ActorCardViewModel> Actors,
-        List<string> Directors,
-        List<string> Writers,
-        string Path,
-        MediaItemState MediaItemState)
-    {
-        public string Poster { get; set; }
-        public string FanArt { get; set; }
-    }
-}
+    public string Poster { get; set; }
+    public string FanArt { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Movies/Queries/GetMovieById.cs b/ErsatzTV.Application/Movies/Queries/GetMovieById.cs
index 7a264190d..10e9073c5 100644
--- a/ErsatzTV.Application/Movies/Queries/GetMovieById.cs
+++ b/ErsatzTV.Application/Movies/Queries/GetMovieById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Movies;
 
-namespace ErsatzTV.Application.Movies.Queries
-{
-    public record GetMovieById(int Id) : IRequest<Option<MovieViewModel>>;
-}
+public record GetMovieById(int Id) : IRequest<Option<MovieViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Movies/Queries/GetMovieByIdHandler.cs b/ErsatzTV.Application/Movies/Queries/GetMovieByIdHandler.cs
index d82415673..07589f58b 100644
--- a/ErsatzTV.Application/Movies/Queries/GetMovieByIdHandler.cs
+++ b/ErsatzTV.Application/Movies/Queries/GetMovieByIdHandler.cs
@@ -1,61 +1,54 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Movies.Mapper;
 
-namespace ErsatzTV.Application.Movies.Queries
+namespace ErsatzTV.Application.Movies;
+
+public class GetMovieByIdHandler : IRequestHandler<GetMovieById, Option<MovieViewModel>>
 {
-    public class GetMovieByIdHandler : IRequestHandler<GetMovieById, Option<MovieViewModel>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMovieRepository _movieRepository;
+
+    public GetMovieByIdHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMovieRepository movieRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMovieRepository _movieRepository;
-
-        public GetMovieByIdHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMovieRepository movieRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _dbContextFactory = dbContextFactory;
-            _movieRepository = movieRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<Option<MovieViewModel>> Handle(
-            GetMovieById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            Option<Movie> movie = await _movieRepository.GetMovie(request.Id);
-
-            Option<MediaVersion> maybeVersion = movie.Map(m => m.MediaVersions.HeadOrNone()).Flatten();
-            var languageCodes = new List<string>();
-            foreach (MediaVersion version in maybeVersion)
-            {
-                var mediaCodes = version.Streams
-                    .Filter(ms => ms.MediaStreamKind == MediaStreamKind.Audio)
-                    .Map(ms => ms.Language)
-                    .ToList();
-
-                languageCodes.AddRange(await dbContext.LanguageCodes.GetAllLanguageCodes(mediaCodes));
-            }
-
-            return movie.Map(m => ProjectToViewModel(m, languageCodes, maybeJellyfin, maybeEmby));
-        }
+        _dbContextFactory = dbContextFactory;
+        _movieRepository = movieRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<Option<MovieViewModel>> Handle(
+        GetMovieById request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        Option<Movie> movie = await _movieRepository.GetMovie(request.Id);
+
+        Option<MediaVersion> maybeVersion = movie.Map(m => m.MediaVersions.HeadOrNone()).Flatten();
+        var languageCodes = new List<string>();
+        foreach (MediaVersion version in maybeVersion)
+        {
+            var mediaCodes = version.Streams
+                .Filter(ms => ms.MediaStreamKind == MediaStreamKind.Audio)
+                .Map(ms => ms.Language)
+                .ToList();
+
+            languageCodes.AddRange(await dbContext.LanguageCodes.GetAllLanguageCodes(mediaCodes));
+        }
+
+        return movie.Map(m => ProjectToViewModel(m, languageCodes, maybeJellyfin, maybeEmby));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/BuildPlayout.cs b/ErsatzTV.Application/Playouts/Commands/BuildPlayout.cs
index 014271147..d3134c9ff 100644
--- a/ErsatzTV.Application/Playouts/Commands/BuildPlayout.cs
+++ b/ErsatzTV.Application/Playouts/Commands/BuildPlayout.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record BuildPlayout(int PlayoutId, bool Rebuild = false) : MediatR.IRequest<Either<BaseError, Unit>>,
-        IBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record BuildPlayout(int PlayoutId, bool Rebuild = false) : MediatR.IRequest<Either<BaseError, Unit>>,
+    IBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs b/ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs
index 0f9eedfb8..26d267f1c 100644
--- a/ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs
+++ b/ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs
@@ -1,73 +1,69 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.Playouts.Commands
+namespace ErsatzTV.Application.Playouts;
+
+public class BuildPlayoutHandler : MediatR.IRequestHandler<BuildPlayout, Either<BaseError, Unit>>
 {
-    public class BuildPlayoutHandler : MediatR.IRequestHandler<BuildPlayout, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IPlayoutBuilder _playoutBuilder;
+
+    public BuildPlayoutHandler(IDbContextFactory<TvContext> dbContextFactory, IPlayoutBuilder playoutBuilder)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IPlayoutBuilder _playoutBuilder;
-
-        public BuildPlayoutHandler(IDbContextFactory<TvContext> dbContextFactory, IPlayoutBuilder playoutBuilder)
-        {
-            _dbContextFactory = dbContextFactory;
-            _playoutBuilder = playoutBuilder;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(BuildPlayout request, CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Playout> validation = await Validate(dbContext, request);
-            return await validation.Apply(playout => ApplyUpdateRequest(dbContext, request, playout));
-        }
-
-        private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, BuildPlayout request, Playout playout)
-        {
-            await _playoutBuilder.BuildPlayoutItems(playout, request.Rebuild);
-            await dbContext.SaveChangesAsync();
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, BuildPlayout request) =>
-            PlayoutMustExist(dbContext, request);
-
-        private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
-            TvContext dbContext,
-            BuildPlayout buildPlayout) =>
-            dbContext.Playouts
-                .Include(p => p.Channel)
-                .Include(p => p.Items)
-                .Include(p => p.ProgramScheduleAnchors)
-                .ThenInclude(a => a.MediaItem)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.Collection)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.MediaItem)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.PreRollFiller)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.MidRollFiller)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.PostRollFiller)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.TailFiller)
-                .Include(p => p.ProgramSchedule)
-                .ThenInclude(ps => ps.Items)
-                .ThenInclude(psi => psi.FallbackFiller)
-                .SelectOneAsync(p => p.Id, p => p.Id == buildPlayout.PlayoutId)
-                .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+        _dbContextFactory = dbContextFactory;
+        _playoutBuilder = playoutBuilder;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(BuildPlayout request, CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Playout> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, playout => ApplyUpdateRequest(dbContext, request, playout));
+    }
+
+    private async Task<Unit> ApplyUpdateRequest(TvContext dbContext, BuildPlayout request, Playout playout)
+    {
+        await _playoutBuilder.BuildPlayoutItems(playout, request.Rebuild);
+        await dbContext.SaveChangesAsync();
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, BuildPlayout request) =>
+        PlayoutMustExist(dbContext, request);
+
+    private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
+        TvContext dbContext,
+        BuildPlayout buildPlayout) =>
+        dbContext.Playouts
+            .Include(p => p.Channel)
+            .Include(p => p.Items)
+            .Include(p => p.ProgramScheduleAnchors)
+            .ThenInclude(a => a.MediaItem)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.Collection)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.MediaItem)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.PreRollFiller)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.MidRollFiller)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.PostRollFiller)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.TailFiller)
+            .Include(p => p.ProgramSchedule)
+            .ThenInclude(ps => ps.Items)
+            .ThenInclude(psi => psi.FallbackFiller)
+            .SelectOneAsync(p => p.Id, p => p.Id == buildPlayout.PlayoutId)
+            .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/CreatePlayout.cs b/ErsatzTV.Application/Playouts/Commands/CreatePlayout.cs
index 68a47d502..29ec84f26 100644
--- a/ErsatzTV.Application/Playouts/Commands/CreatePlayout.cs
+++ b/ErsatzTV.Application/Playouts/Commands/CreatePlayout.cs
@@ -1,12 +1,9 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record CreatePlayout(
-        int ChannelId,
-        int ProgramScheduleId,
-        ProgramSchedulePlayoutType ProgramSchedulePlayoutType) : IRequest<Either<BaseError, CreatePlayoutResponse>>;
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record CreatePlayout(
+    int ChannelId,
+    int ProgramScheduleId,
+    ProgramSchedulePlayoutType ProgramSchedulePlayoutType) : IRequest<Either<BaseError, CreatePlayoutResponse>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/CreatePlayoutHandler.cs b/ErsatzTV.Application/Playouts/Commands/CreatePlayoutHandler.cs
index 48c6a3e5b..1b346d1d5 100644
--- a/ErsatzTV.Application/Playouts/Commands/CreatePlayoutHandler.cs
+++ b/ErsatzTV.Application/Playouts/Commands/CreatePlayoutHandler.cs
@@ -1,95 +1,88 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 using Channel = ErsatzTV.Core.Domain.Channel;
 
-namespace ErsatzTV.Application.Playouts.Commands
+namespace ErsatzTV.Application.Playouts;
+
+public class CreatePlayoutHandler : IRequestHandler<CreatePlayout, Either<BaseError, CreatePlayoutResponse>>
 {
-    public class CreatePlayoutHandler : IRequestHandler<CreatePlayout, Either<BaseError, CreatePlayoutResponse>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreatePlayoutHandler(
+        ChannelWriter<IBackgroundServiceRequest> channel,
+        IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreatePlayoutHandler(
-            ChannelWriter<IBackgroundServiceRequest> channel,
-            IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _channel = channel;
-            _dbContextFactory = dbContextFactory;
-        }
-
-        public async Task<Either<BaseError, CreatePlayoutResponse>> Handle(
-            CreatePlayout request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Validation<BaseError, Playout> validation = await Validate(dbContext, request);
-            return await validation.Apply(playout => PersistPlayout(dbContext, playout));
-        }
-
-        private async Task<CreatePlayoutResponse> PersistPlayout(TvContext dbContext, Playout playout)
-        {
-            await dbContext.Playouts.AddAsync(playout);
-            await dbContext.SaveChangesAsync();
-            await _channel.WriteAsync(new BuildPlayout(playout.Id));
-            return new CreatePlayoutResponse(playout.Id);
-        }
-
-        private async Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, CreatePlayout request) =>
-            (await ValidateChannel(dbContext, request), await ValidateProgramSchedule(dbContext, request),
-                ValidatePlayoutType(request))
-            .Apply(
-                (channel, programSchedule, playoutType) => new Playout
-                {
-                    ChannelId = channel.Id,
-                    ProgramScheduleId = programSchedule.Id,
-                    ProgramSchedulePlayoutType = playoutType
-                });
-
-        private static Task<Validation<BaseError, Channel>> ValidateChannel(
-            TvContext dbContext,
-            CreatePlayout createPlayout) =>
-            dbContext.Channels
-                .Include(c => c.Playouts)
-                .SelectOneAsync(c => c.Id, c => c.Id == createPlayout.ChannelId)
-                .Map(o => o.ToValidation<BaseError>("Channel does not exist"))
-                .BindT(ChannelMustNotHavePlayouts);
-
-        private static Validation<BaseError, Channel> ChannelMustNotHavePlayouts(Channel channel) =>
-            Optional(channel.Playouts.Count)
-                .Filter(count => count == 0)
-                .Map(_ => channel)
-                .ToValidation<BaseError>("Channel already has one playout");
-
-        private static Task<Validation<BaseError, ProgramSchedule>> ValidateProgramSchedule(
-            TvContext dbContext,
-            CreatePlayout createPlayout) =>
-            dbContext.ProgramSchedules
-                .Include(ps => ps.Items)
-                .SelectOneAsync(ps => ps.Id, ps => ps.Id == createPlayout.ProgramScheduleId)
-                .Map(o => o.ToValidation<BaseError>("Program schedule does not exist"))
-                .BindT(ProgramScheduleMustHaveItems);
-
-        private static Validation<BaseError, ProgramSchedule> ProgramScheduleMustHaveItems(
-            ProgramSchedule programSchedule) =>
-            Optional(programSchedule)
-                .Filter(ps => ps.Items.Any())
-                .ToValidation<BaseError>("Program schedule must have items");
-
-        private static Validation<BaseError, ProgramSchedulePlayoutType> ValidatePlayoutType(
-            CreatePlayout createPlayout) =>
-            Optional(createPlayout.ProgramSchedulePlayoutType)
-                .Filter(playoutType => playoutType != ProgramSchedulePlayoutType.None)
-                .ToValidation<BaseError>("[ProgramSchedulePlayoutType] must not be None");
+        _channel = channel;
+        _dbContextFactory = dbContextFactory;
     }
-}
+
+    public async Task<Either<BaseError, CreatePlayoutResponse>> Handle(
+        CreatePlayout request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        Validation<BaseError, Playout> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, playout => PersistPlayout(dbContext, playout));
+    }
+
+    private async Task<CreatePlayoutResponse> PersistPlayout(TvContext dbContext, Playout playout)
+    {
+        await dbContext.Playouts.AddAsync(playout);
+        await dbContext.SaveChangesAsync();
+        await _channel.WriteAsync(new BuildPlayout(playout.Id));
+        return new CreatePlayoutResponse(playout.Id);
+    }
+
+    private async Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, CreatePlayout request) =>
+        (await ValidateChannel(dbContext, request), await ValidateProgramSchedule(dbContext, request),
+            ValidatePlayoutType(request))
+        .Apply(
+            (channel, programSchedule, playoutType) => new Playout
+            {
+                ChannelId = channel.Id,
+                ProgramScheduleId = programSchedule.Id,
+                ProgramSchedulePlayoutType = playoutType
+            });
+
+    private static Task<Validation<BaseError, Channel>> ValidateChannel(
+        TvContext dbContext,
+        CreatePlayout createPlayout) =>
+        dbContext.Channels
+            .Include(c => c.Playouts)
+            .SelectOneAsync(c => c.Id, c => c.Id == createPlayout.ChannelId)
+            .Map(o => o.ToValidation<BaseError>("Channel does not exist"))
+            .BindT(ChannelMustNotHavePlayouts);
+
+    private static Validation<BaseError, Channel> ChannelMustNotHavePlayouts(Channel channel) =>
+        Optional(channel.Playouts.Count)
+            .Filter(count => count == 0)
+            .Map(_ => channel)
+            .ToValidation<BaseError>("Channel already has one playout");
+
+    private static Task<Validation<BaseError, ProgramSchedule>> ValidateProgramSchedule(
+        TvContext dbContext,
+        CreatePlayout createPlayout) =>
+        dbContext.ProgramSchedules
+            .Include(ps => ps.Items)
+            .SelectOneAsync(ps => ps.Id, ps => ps.Id == createPlayout.ProgramScheduleId)
+            .Map(o => o.ToValidation<BaseError>("Program schedule does not exist"))
+            .BindT(ProgramScheduleMustHaveItems);
+
+    private static Validation<BaseError, ProgramSchedule> ProgramScheduleMustHaveItems(
+        ProgramSchedule programSchedule) =>
+        Optional(programSchedule)
+            .Filter(ps => ps.Items.Any())
+            .ToValidation<BaseError>("Program schedule must have items");
+
+    private static Validation<BaseError, ProgramSchedulePlayoutType> ValidatePlayoutType(
+        CreatePlayout createPlayout) =>
+        Optional(createPlayout.ProgramSchedulePlayoutType)
+            .Filter(playoutType => playoutType != ProgramSchedulePlayoutType.None)
+            .ToValidation<BaseError>("[ProgramSchedulePlayoutType] must not be None");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/CreatePlayoutResponse.cs b/ErsatzTV.Application/Playouts/Commands/CreatePlayoutResponse.cs
index c5d266f89..fb4d596b6 100644
--- a/ErsatzTV.Application/Playouts/Commands/CreatePlayoutResponse.cs
+++ b/ErsatzTV.Application/Playouts/Commands/CreatePlayoutResponse.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record CreatePlayoutResponse(int PlayoutId);
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record CreatePlayoutResponse(int PlayoutId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/DeletePlayout.cs b/ErsatzTV.Application/Playouts/Commands/DeletePlayout.cs
index ddbb53384..6ccc3dd74 100644
--- a/ErsatzTV.Application/Playouts/Commands/DeletePlayout.cs
+++ b/ErsatzTV.Application/Playouts/Commands/DeletePlayout.cs
@@ -1,9 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record DeletePlayout(int PlayoutId) : IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record DeletePlayout(int PlayoutId) : IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/DeletePlayoutHandler.cs b/ErsatzTV.Application/Playouts/Commands/DeletePlayoutHandler.cs
index 9240ab05e..6e26187e0 100644
--- a/ErsatzTV.Application/Playouts/Commands/DeletePlayoutHandler.cs
+++ b/ErsatzTV.Application/Playouts/Commands/DeletePlayoutHandler.cs
@@ -1,42 +1,35 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Playouts.Commands
+namespace ErsatzTV.Application.Playouts;
+
+public class DeletePlayoutHandler : IRequestHandler<DeletePlayout, Either<BaseError, Unit>>
 {
-    public class DeletePlayoutHandler : IRequestHandler<DeletePlayout, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeletePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeletePlayout request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-        public DeletePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        Option<Playout> maybePlayout = await dbContext.Playouts
+            .OrderBy(p => p.Id)
+            .FirstOrDefaultAsync(p => p.Id == request.PlayoutId, cancellationToken);
 
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeletePlayout request,
-            CancellationToken cancellationToken)
+        foreach (Playout playout in maybePlayout)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Option<Playout> maybePlayout = await dbContext.Playouts
-                .OrderBy(p => p.Id)
-                .FirstOrDefaultAsync(p => p.Id == request.PlayoutId, cancellationToken);
-
-            foreach (Playout playout in maybePlayout)
-            {
-                dbContext.Playouts.Remove(playout);
-                await dbContext.SaveChangesAsync(cancellationToken);
-            }
-
-            return maybePlayout
-                .Map(_ => Unit.Default)
-                .ToEither(BaseError.New($"Playout {request.PlayoutId} does not exist."));
+            dbContext.Playouts.Remove(playout);
+            await dbContext.SaveChangesAsync(cancellationToken);
         }
+
+        return maybePlayout
+            .Map(_ => Unit.Default)
+            .ToEither(BaseError.New($"Playout {request.PlayoutId} does not exist."));
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs b/ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs
index fc13cc2fb..1668286bb 100644
--- a/ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs
+++ b/ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs
@@ -1,10 +1,6 @@
-using System;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Playouts.Commands
-{
-    public record UpdatePlayout
-        (int PlayoutId, Option<TimeSpan> DailyRebuildTime) : IRequest<Either<BaseError, PlayoutNameViewModel>>;
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record UpdatePlayout
+    (int PlayoutId, Option<TimeSpan> DailyRebuildTime) : IRequest<Either<BaseError, PlayoutNameViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs b/ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs
index a95766ba9..9bf853ea6 100644
--- a/ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs
+++ b/ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs
@@ -1,65 +1,58 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Playouts.Commands
+namespace ErsatzTV.Application.Playouts;
+
+public class UpdatePlayoutHandler : IRequestHandler<UpdatePlayout, Either<BaseError, PlayoutNameViewModel>>
 {
-    public class UpdatePlayoutHandler : IRequestHandler<UpdatePlayout, Either<BaseError, PlayoutNameViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdatePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, PlayoutNameViewModel>> Handle(
+        UpdatePlayout request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdatePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, PlayoutNameViewModel>> Handle(
-            UpdatePlayout request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, Playout> validation = await Validate(dbContext, request);
-            return await validation.Apply(playout => ApplyUpdateRequest(dbContext, request, playout));
-        }
-
-        private static async Task<PlayoutNameViewModel> ApplyUpdateRequest(
-            TvContext dbContext,
-            UpdatePlayout request,
-            Playout playout)
-        {
-            playout.DailyRebuildTime = null;
-
-            foreach (TimeSpan dailyRebuildTime in request.DailyRebuildTime)
-            {
-                playout.DailyRebuildTime = dailyRebuildTime;
-            }
-
-            await dbContext.SaveChangesAsync();
-
-            return new PlayoutNameViewModel(
-                playout.Id,
-                playout.Channel.Name,
-                playout.Channel.Number,
-                playout.ProgramSchedule.Name,
-                Optional(playout.DailyRebuildTime));
-        }
-
-        private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, UpdatePlayout request) =>
-            PlayoutMustExist(dbContext, request);
-
-        private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
-            TvContext dbContext,
-            UpdatePlayout updatePlayout) =>
-            dbContext.Playouts
-                .Include(p => p.Channel)
-                .Include(p => p.ProgramSchedule)
-                .SelectOneAsync(p => p.Id, p => p.Id == updatePlayout.PlayoutId)
-                .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, Playout> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, playout => ApplyUpdateRequest(dbContext, request, playout));
     }
-}
+
+    private static async Task<PlayoutNameViewModel> ApplyUpdateRequest(
+        TvContext dbContext,
+        UpdatePlayout request,
+        Playout playout)
+    {
+        playout.DailyRebuildTime = null;
+
+        foreach (TimeSpan dailyRebuildTime in request.DailyRebuildTime)
+        {
+            playout.DailyRebuildTime = dailyRebuildTime;
+        }
+
+        await dbContext.SaveChangesAsync();
+
+        return new PlayoutNameViewModel(
+            playout.Id,
+            playout.Channel.Name,
+            playout.Channel.Number,
+            playout.ProgramSchedule.Name,
+            Optional(playout.DailyRebuildTime));
+    }
+
+    private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, UpdatePlayout request) =>
+        PlayoutMustExist(dbContext, request);
+
+    private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
+        TvContext dbContext,
+        UpdatePlayout updatePlayout) =>
+        dbContext.Playouts
+            .Include(p => p.Channel)
+            .Include(p => p.ProgramSchedule)
+            .SelectOneAsync(p => p.Id, p => p.Id == updatePlayout.PlayoutId)
+            .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Mapper.cs b/ErsatzTV.Application/Playouts/Mapper.cs
index 1dc658877..b4e1ed56d 100644
--- a/ErsatzTV.Application/Playouts/Mapper.cs
+++ b/ErsatzTV.Application/Playouts/Mapper.cs
@@ -1,69 +1,66 @@
-using System;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Playouts
+namespace ErsatzTV.Application.Playouts;
+
+internal static class Mapper
 {
-    internal static class Mapper
+    internal static PlayoutItemViewModel ProjectToViewModel(PlayoutItem playoutItem) =>
+        new(
+            GetDisplayTitle(playoutItem),
+            playoutItem.StartOffset,
+            GetDisplayDuration(playoutItem.FinishOffset - playoutItem.StartOffset));
+
+    private static string GetDisplayTitle(PlayoutItem playoutItem)
     {
-        internal static PlayoutItemViewModel ProjectToViewModel(PlayoutItem playoutItem) =>
-            new(
-                GetDisplayTitle(playoutItem),
-                playoutItem.StartOffset,
-                GetDisplayDuration(playoutItem.FinishOffset - playoutItem.StartOffset));
-
-        private static string GetDisplayTitle(PlayoutItem playoutItem)
+        switch (playoutItem.MediaItem)
         {
-            switch (playoutItem.MediaItem)
-            {
-                case Episode e:
-                    string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
-                        .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
-                    var episodeNumbers = e.EpisodeMetadata.Map(em => em.EpisodeNumber).ToList();
-                    var episodeTitles = e.EpisodeMetadata.Map(em => em.Title).ToList();
-                    if (episodeNumbers.Count == 0 || episodeTitles.Count == 0)
-                    {
-                        return "[unknown episode]";
-                    }
+            case Episode e:
+                string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
+                    .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
+                var episodeNumbers = e.EpisodeMetadata.Map(em => em.EpisodeNumber).ToList();
+                var episodeTitles = e.EpisodeMetadata.Map(em => em.Title).ToList();
+                if (episodeNumbers.Count == 0 || episodeTitles.Count == 0)
+                {
+                    return "[unknown episode]";
+                }
 
-                    var numbersString = $"e{string.Join('e', episodeNumbers.Map(n => $"{n:00}"))}";
-                    var titlesString = $"{string.Join('/', episodeTitles)}";
-                    if (!string.IsNullOrWhiteSpace(playoutItem.ChapterTitle))
-                    {
-                        titlesString += $" ({playoutItem.ChapterTitle})";
-                    }
+                var numbersString = $"e{string.Join('e', episodeNumbers.Map(n => $"{n:00}"))}";
+                var titlesString = $"{string.Join('/', episodeTitles)}";
+                if (!string.IsNullOrWhiteSpace(playoutItem.ChapterTitle))
+                {
+                    titlesString += $" ({playoutItem.ChapterTitle})";
+                }
 
-                    return $"{showTitle}s{e.Season.SeasonNumber:00}{numbersString} - {titlesString}";
-                case Movie m:
-                    return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
-                case MusicVideo mv:
-                    string artistName = mv.Artist.ArtistMetadata.HeadOrNone()
-                        .Map(am => $"{am.Title} - ").IfNone(string.Empty);
-                    return mv.MusicVideoMetadata.HeadOrNone()
-                        .Map(mvm => $"{artistName}{mvm.Title}")
-                        .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
-                        .IfNone("[unknown music video]");
-                case OtherVideo ov:
-                    return ov.OtherVideoMetadata.HeadOrNone()
-                        .Map(ovm => ovm.Title ?? string.Empty)
-                        .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
-                        .IfNone("[unknown video]");
-                case Song s:
-                    string songArtist = s.SongMetadata.HeadOrNone()
-                        .Map(sm => string.IsNullOrWhiteSpace(sm.Artist) ? string.Empty : $"{sm.Artist} - ")
-                        .IfNone(string.Empty);
-                    return s.SongMetadata.HeadOrNone()
-                        .Map(sm => $"{songArtist}{sm.Title ?? string.Empty}")
-                        .Map(t => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? t : $"{s} ({playoutItem.ChapterTitle})")
-                        .IfNone("[unknown song]");
-                default:
-                    return string.Empty;
-            }
+                return $"{showTitle}s{e.Season.SeasonNumber:00}{numbersString} - {titlesString}";
+            case Movie m:
+                return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
+            case MusicVideo mv:
+                string artistName = mv.Artist.ArtistMetadata.HeadOrNone()
+                    .Map(am => $"{am.Title} - ").IfNone(string.Empty);
+                return mv.MusicVideoMetadata.HeadOrNone()
+                    .Map(mvm => $"{artistName}{mvm.Title}")
+                    .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
+                    .IfNone("[unknown music video]");
+            case OtherVideo ov:
+                return ov.OtherVideoMetadata.HeadOrNone()
+                    .Map(ovm => ovm.Title ?? string.Empty)
+                    .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
+                    .IfNone("[unknown video]");
+            case Song s:
+                string songArtist = s.SongMetadata.HeadOrNone()
+                    .Map(sm => string.IsNullOrWhiteSpace(sm.Artist) ? string.Empty : $"{sm.Artist} - ")
+                    .IfNone(string.Empty);
+                return s.SongMetadata.HeadOrNone()
+                    .Map(sm => $"{songArtist}{sm.Title ?? string.Empty}")
+                    .Map(t => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? t : $"{s} ({playoutItem.ChapterTitle})")
+                    .IfNone("[unknown song]");
+            default:
+                return string.Empty;
         }
-
-        private static string GetDisplayDuration(TimeSpan duration) =>
-            string.Format(
-                duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
-                duration);
     }
-}
+
+    private static string GetDisplayDuration(TimeSpan duration) =>
+        string.Format(
+            duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
+            duration);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/PagedPlayoutItemsViewModel.cs b/ErsatzTV.Application/Playouts/PagedPlayoutItemsViewModel.cs
index 11260308f..0e6568dc5 100644
--- a/ErsatzTV.Application/Playouts/PagedPlayoutItemsViewModel.cs
+++ b/ErsatzTV.Application/Playouts/PagedPlayoutItemsViewModel.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts
-{
-    public record PagedPlayoutItemsViewModel(int TotalCount, List<PlayoutItemViewModel> Page);
-}
+public record PagedPlayoutItemsViewModel(int TotalCount, List<PlayoutItemViewModel> Page);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/PlayoutChannelViewModel.cs b/ErsatzTV.Application/Playouts/PlayoutChannelViewModel.cs
index d21d6e00c..3968e90a2 100644
--- a/ErsatzTV.Application/Playouts/PlayoutChannelViewModel.cs
+++ b/ErsatzTV.Application/Playouts/PlayoutChannelViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutChannelViewModel(int Id, string Number, string Name);
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record PlayoutChannelViewModel(int Id, string Number, string Name);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/PlayoutItemViewModel.cs b/ErsatzTV.Application/Playouts/PlayoutItemViewModel.cs
index 5e064c037..118ba6536 100644
--- a/ErsatzTV.Application/Playouts/PlayoutItemViewModel.cs
+++ b/ErsatzTV.Application/Playouts/PlayoutItemViewModel.cs
@@ -1,6 +1,3 @@
-using System;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutItemViewModel(string Title, DateTimeOffset Start, string Duration);
-}
+public record PlayoutItemViewModel(string Title, DateTimeOffset Start, string Duration);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs b/ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs
index d727f112c..9aeaeb386 100644
--- a/ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs
+++ b/ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs
@@ -1,12 +1,8 @@
-using System;
-using LanguageExt;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutNameViewModel(
-        int PlayoutId,
-        string ChannelName,
-        string ChannelNumber,
-        string ScheduleName,
-        Option<TimeSpan> DailyRebuildTime);
-}
+public record PlayoutNameViewModel(
+    int PlayoutId,
+    string ChannelName,
+    string ChannelNumber,
+    string ScheduleName,
+    Option<TimeSpan> DailyRebuildTime);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/PlayoutProgramScheduleViewModel.cs b/ErsatzTV.Application/Playouts/PlayoutProgramScheduleViewModel.cs
index 1d1ca0049..e4e3e9824 100644
--- a/ErsatzTV.Application/Playouts/PlayoutProgramScheduleViewModel.cs
+++ b/ErsatzTV.Application/Playouts/PlayoutProgramScheduleViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutProgramScheduleViewModel(int Id, string Name);
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record PlayoutProgramScheduleViewModel(int Id, string Name);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/PlayoutViewModel.cs b/ErsatzTV.Application/Playouts/PlayoutViewModel.cs
index 978a35046..55bf72ea7 100644
--- a/ErsatzTV.Application/Playouts/PlayoutViewModel.cs
+++ b/ErsatzTV.Application/Playouts/PlayoutViewModel.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Playouts
-{
-    public record PlayoutViewModel(
-        int Id,
-        PlayoutChannelViewModel Channel,
-        PlayoutProgramScheduleViewModel ProgramSchedule,
-        ProgramSchedulePlayoutType ProgramSchedulePlayoutType);
-}
+namespace ErsatzTV.Application.Playouts;
+
+public record PlayoutViewModel(
+    int Id,
+    PlayoutChannelViewModel Channel,
+    PlayoutProgramScheduleViewModel ProgramSchedule,
+    ProgramSchedulePlayoutType ProgramSchedulePlayoutType);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Queries/GetAllPlayouts.cs b/ErsatzTV.Application/Playouts/Queries/GetAllPlayouts.cs
index ae258c66a..429eb6f43 100644
--- a/ErsatzTV.Application/Playouts/Queries/GetAllPlayouts.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetAllPlayouts.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts.Queries
-{
-    public record GetAllPlayouts : IRequest<List<PlayoutNameViewModel>>;
-}
+public record GetAllPlayouts : IRequest<List<PlayoutNameViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs b/ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs
index d2e85a5b7..f26922620 100644
--- a/ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs
@@ -1,35 +1,29 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Playouts.Queries
+namespace ErsatzTV.Application.Playouts;
+
+public class GetAllPlayoutsHandler : IRequestHandler<GetAllPlayouts, List<PlayoutNameViewModel>>
 {
-    public class GetAllPlayoutsHandler : IRequestHandler<GetAllPlayouts, List<PlayoutNameViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllPlayoutsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<PlayoutNameViewModel>> Handle(
+        GetAllPlayouts request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllPlayoutsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<PlayoutNameViewModel>> Handle(
-            GetAllPlayouts request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Playouts
-                .Filter(p => p.Channel != null && p.ProgramSchedule != null)
-                .Map(
-                    p => new PlayoutNameViewModel(
-                        p.Id,
-                        p.Channel.Name,
-                        p.Channel.Number,
-                        p.ProgramSchedule.Name,
-                        Optional(p.DailyRebuildTime)))
-                .ToListAsync(cancellationToken);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Playouts
+            .Filter(p => p.Channel != null && p.ProgramSchedule != null)
+            .Map(
+                p => new PlayoutNameViewModel(
+                    p.Id,
+                    p.Channel.Name,
+                    p.Channel.Number,
+                    p.ProgramSchedule.Name,
+                    Optional(p.DailyRebuildTime)))
+            .ToListAsync(cancellationToken);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs b/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs
index b831c8726..a134ffb1d 100644
--- a/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.Playouts;
 
-namespace ErsatzTV.Application.Playouts.Queries
-{
-    public record GetFuturePlayoutItemsById(int PlayoutId, bool ShowFiller, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
-}
+public record GetFuturePlayoutItemsById(int PlayoutId, bool ShowFiller, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs b/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs
index a22182887..1e87870c0 100644
--- a/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs
@@ -1,76 +1,68 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Playouts.Mapper;
 
-namespace ErsatzTV.Application.Playouts.Queries
+namespace ErsatzTV.Application.Playouts;
+
+public class GetFuturePlayoutItemsByIdHandler : IRequestHandler<GetFuturePlayoutItemsById, PagedPlayoutItemsViewModel>
 {
-    public class GetFuturePlayoutItemsByIdHandler : IRequestHandler<GetFuturePlayoutItemsById, PagedPlayoutItemsViewModel>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetFuturePlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<PagedPlayoutItemsViewModel> Handle(
+        GetFuturePlayoutItemsById request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
-        public GetFuturePlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        DateTime now = DateTimeOffset.Now.UtcDateTime;
 
-        public async Task<PagedPlayoutItemsViewModel> Handle(
-            GetFuturePlayoutItemsById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-            DateTime now = DateTimeOffset.Now.UtcDateTime;
-
-            int totalCount = await dbContext.PlayoutItems
-                .CountAsync(i => i.Finish >= now && i.PlayoutId == request.PlayoutId && (request.ShowFiller || i.FillerKind == FillerKind.None), cancellationToken);
+        int totalCount = await dbContext.PlayoutItems
+            .CountAsync(i => i.Finish >= now && i.PlayoutId == request.PlayoutId && (request.ShowFiller || i.FillerKind == FillerKind.None), cancellationToken);
             
-            List<PlayoutItemViewModel> page = await dbContext.PlayoutItems
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Movie).MovieMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Movie).MediaVersions)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as MusicVideo).MusicVideoMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as MusicVideo).Artist)
-                .ThenInclude(mm => mm.ArtistMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).EpisodeMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).MediaVersions)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).Season)
-                .ThenInclude(s => s.SeasonMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).Season.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Song).SongMetadata)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Song).MediaVersions)
-                .Filter(i => i.PlayoutId == request.PlayoutId)
-                .Filter(i => i.Finish >= now)
-                .Filter(i => request.ShowFiller || i.FillerKind == FillerKind.None)
-                .OrderBy(i => i.Start)
-                .Skip(request.PageNum * request.PageSize)
-                .Take(request.PageSize)
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
+        List<PlayoutItemViewModel> page = await dbContext.PlayoutItems
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Movie).MovieMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Movie).MediaVersions)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).MusicVideoMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).Artist)
+            .ThenInclude(mm => mm.ArtistMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).EpisodeMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).MediaVersions)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).Season)
+            .ThenInclude(s => s.SeasonMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).Season.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Song).SongMetadata)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Song).MediaVersions)
+            .Filter(i => i.PlayoutId == request.PlayoutId)
+            .Filter(i => i.Finish >= now)
+            .Filter(i => request.ShowFiller || i.FillerKind == FillerKind.None)
+            .OrderBy(i => i.Start)
+            .Skip(request.PageNum * request.PageSize)
+            .Take(request.PageSize)
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
 
-            return new PagedPlayoutItemsViewModel(totalCount, page);
-        }
+        return new PagedPlayoutItemsViewModel(totalCount, page);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/SignOutOfPlex.cs b/ErsatzTV.Application/Plex/Commands/SignOutOfPlex.cs
index 926f318ed..5a8e96665 100644
--- a/ErsatzTV.Application/Plex/Commands/SignOutOfPlex.cs
+++ b/ErsatzTV.Application/Plex/Commands/SignOutOfPlex.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Plex.Commands
-{
-    public record SignOutOfPlex : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Plex;
+
+public record SignOutOfPlex : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/SignOutOfPlexHandler.cs b/ErsatzTV.Application/Plex/Commands/SignOutOfPlexHandler.cs
index 3d4227230..076d3dfb4 100644
--- a/ErsatzTV.Application/Plex/Commands/SignOutOfPlexHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/SignOutOfPlexHandler.cs
@@ -1,43 +1,38 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public class SignOutOfPlexHandler : MediatR.IRequestHandler<SignOutOfPlex, Either<BaseError, Unit>>
 {
-    public class SignOutOfPlexHandler : MediatR.IRequestHandler<SignOutOfPlex, Either<BaseError, Unit>>
+    private readonly IEntityLocker _entityLocker;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IPlexSecretStore _plexSecretStore;
+    private readonly ISearchIndex _searchIndex;
+
+    public SignOutOfPlexHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IPlexSecretStore plexSecretStore,
+        IEntityLocker entityLocker,
+        ISearchIndex searchIndex)
     {
-        private readonly IEntityLocker _entityLocker;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IPlexSecretStore _plexSecretStore;
-        private readonly ISearchIndex _searchIndex;
-
-        public SignOutOfPlexHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IPlexSecretStore plexSecretStore,
-            IEntityLocker entityLocker,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _plexSecretStore = plexSecretStore;
-            _entityLocker = entityLocker;
-            _searchIndex = searchIndex;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(SignOutOfPlex request, CancellationToken cancellationToken)
-        {
-            List<int> ids = await _mediaSourceRepository.DeleteAllPlex();
-            await _searchIndex.RemoveItems(ids);
-            _searchIndex.Commit();
-            await _plexSecretStore.DeleteAll();
-            _entityLocker.UnlockPlex();
-
-            return Unit.Default;
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _plexSecretStore = plexSecretStore;
+        _entityLocker = entityLocker;
+        _searchIndex = searchIndex;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(SignOutOfPlex request, CancellationToken cancellationToken)
+    {
+        List<int> ids = await _mediaSourceRepository.DeleteAllPlex();
+        await _searchIndex.RemoveItems(ids);
+        _searchIndex.Commit();
+        await _plexSecretStore.DeleteAll();
+        _entityLocker.UnlockPlex();
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/StartPlexPinFlow.cs b/ErsatzTV.Application/Plex/Commands/StartPlexPinFlow.cs
index 5c5eebbc2..62e6c62ec 100644
--- a/ErsatzTV.Application/Plex/Commands/StartPlexPinFlow.cs
+++ b/ErsatzTV.Application/Plex/Commands/StartPlexPinFlow.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Plex.Commands
-{
-    public record StartPlexPinFlow : IRequest<Either<BaseError, string>>;
-}
+namespace ErsatzTV.Application.Plex;
+
+public record StartPlexPinFlow : IRequest<Either<BaseError, string>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/StartPlexPinFlowHandler.cs b/ErsatzTV.Application/Plex/Commands/StartPlexPinFlowHandler.cs
index 869897018..4c417b83b 100644
--- a/ErsatzTV.Application/Plex/Commands/StartPlexPinFlowHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/StartPlexPinFlowHandler.cs
@@ -1,38 +1,32 @@
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Plex;
-using LanguageExt;
-using MediatR;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public class StartPlexPinFlowHandler : IRequestHandler<StartPlexPinFlow, Either<BaseError, string>>
 {
-    public class StartPlexPinFlowHandler : IRequestHandler<StartPlexPinFlow, Either<BaseError, string>>
+    private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
+    private readonly IPlexTvApiClient _plexTvApiClient;
+
+    public StartPlexPinFlowHandler(
+        IPlexTvApiClient plexTvApiClient,
+        ChannelWriter<IPlexBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
-        private readonly IPlexTvApiClient _plexTvApiClient;
-
-        public StartPlexPinFlowHandler(
-            IPlexTvApiClient plexTvApiClient,
-            ChannelWriter<IPlexBackgroundServiceRequest> channel)
-        {
-            _plexTvApiClient = plexTvApiClient;
-            _channel = channel;
-        }
-
-        public Task<Either<BaseError, string>> Handle(
-            StartPlexPinFlow request,
-            CancellationToken cancellationToken) =>
-            _plexTvApiClient.StartPinFlow().Bind(
-                result => result.Match(
-                    Left: error => Task.FromResult(Left<BaseError, string>(error)),
-                    Right: async pin =>
-                    {
-                        await _channel.WriteAsync(new TryCompletePlexPinFlow(pin), cancellationToken);
-                        return Right<BaseError, string>(pin.Url);
-                    })
-            );
+        _plexTvApiClient = plexTvApiClient;
+        _channel = channel;
     }
-}
+
+    public Task<Either<BaseError, string>> Handle(
+        StartPlexPinFlow request,
+        CancellationToken cancellationToken) =>
+        _plexTvApiClient.StartPinFlow().Bind(
+            result => result.Match(
+                Left: error => Task.FromResult(Left<BaseError, string>(error)),
+                Right: async pin =>
+                {
+                    await _channel.WriteAsync(new TryCompletePlexPinFlow(pin), cancellationToken);
+                    return Right<BaseError, string>(pin.Url);
+                })
+        );
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraries.cs b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraries.cs
index 9640fc735..4f23bcab6 100644
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraries.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraries.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Plex.Commands
-{
-    public record SynchronizePlexLibraries(int PlexMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
-        IPlexBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Plex;
+
+public record SynchronizePlexLibraries(int PlexMediaSourceId) : MediatR.IRequest<Either<BaseError, Unit>>,
+    IPlexBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibrariesHandler.cs b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibrariesHandler.cs
index c970ec314..76ca7f64c 100644
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibrariesHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibrariesHandler.cs
@@ -1,115 +1,109 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public class
+    SynchronizePlexLibrariesHandler : MediatR.IRequestHandler<SynchronizePlexLibraries, Either<BaseError, Unit>>
 {
-    public class
-        SynchronizePlexLibrariesHandler : MediatR.IRequestHandler<SynchronizePlexLibraries, Either<BaseError, Unit>>
+    private readonly ILogger<SynchronizePlexLibrariesHandler> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IPlexSecretStore _plexSecretStore;
+    private readonly IPlexServerApiClient _plexServerApiClient;
+    private readonly ISearchIndex _searchIndex;
+
+    public SynchronizePlexLibrariesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IPlexSecretStore plexSecretStore,
+        IPlexServerApiClient plexServerApiClient,
+        ILogger<SynchronizePlexLibrariesHandler> logger,
+        ISearchIndex searchIndex)
     {
-        private readonly ILogger<SynchronizePlexLibrariesHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IPlexSecretStore _plexSecretStore;
-        private readonly IPlexServerApiClient _plexServerApiClient;
-        private readonly ISearchIndex _searchIndex;
-
-        public SynchronizePlexLibrariesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IPlexSecretStore plexSecretStore,
-            IPlexServerApiClient plexServerApiClient,
-            ILogger<SynchronizePlexLibrariesHandler> logger,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _plexSecretStore = plexSecretStore;
-            _plexServerApiClient = plexServerApiClient;
-            _logger = logger;
-            _searchIndex = searchIndex;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(
-            SynchronizePlexLibraries request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(SynchronizeLibraries)
-                .Bind(v => v.ToEitherAsync());
-
-        private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizePlexLibraries request) =>
-            MediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveToken);
-
-        private Task<Validation<BaseError, PlexMediaSource>> MediaSourceMustExist(SynchronizePlexLibraries request) =>
-            _mediaSourceRepository.GetPlex(request.PlexMediaSourceId)
-                .Map(o => o.ToValidation<BaseError>("Plex media source does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            PlexMediaSource plexMediaSource)
-        {
-            Option<PlexConnection> maybeConnection =
-                plexMediaSource.Connections.SingleOrDefault(c => c.IsActive);
-            return maybeConnection.Map(connection => new ConnectionParameters(plexMediaSource, connection))
-                .ToValidation<BaseError>("Plex media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveToken(
-            ConnectionParameters connectionParameters)
-        {
-            Option<PlexServerAuthToken> maybeToken = await
-                _plexSecretStore.GetServerAuthToken(connectionParameters.PlexMediaSource.ClientIdentifier);
-            return maybeToken.Map(token => connectionParameters with { PlexServerAuthToken = token })
-                .ToValidation<BaseError>("Plex media source requires a token");
-        }
-
-        private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
-        {
-            Either<BaseError, List<PlexLibrary>> maybeLibraries = await _plexServerApiClient.GetLibraries(
-                connectionParameters.ActiveConnection,
-                connectionParameters.PlexServerAuthToken);
-
-            await maybeLibraries.Match(
-                async libraries =>
-                {
-                    var existing = connectionParameters.PlexMediaSource.Libraries.OfType<PlexLibrary>().ToList();
-                    var toAdd = libraries.Filter(library => existing.All(l => l.Key != library.Key)).ToList();
-                    var toRemove = existing.Filter(library => libraries.All(l => l.Key != library.Key)).ToList();
-                    List<int> ids = await _mediaSourceRepository.UpdateLibraries(
-                        connectionParameters.PlexMediaSource.Id,
-                        toAdd,
-                        toRemove);
-                    if (ids.Any())
-                    {
-                        await _searchIndex.RemoveItems(ids);
-                        _searchIndex.Commit();
-                    }
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Unable to synchronize libraries from plex server {PlexServer}: {Error}",
-                        connectionParameters.PlexMediaSource.ServerName,
-                        error.Value);
-
-                    return Task.CompletedTask;
-                });
-
-            return Unit.Default;
-        }
-
-        private record ConnectionParameters(
-            PlexMediaSource PlexMediaSource,
-            PlexConnection ActiveConnection)
-        {
-            public PlexServerAuthToken PlexServerAuthToken { get; set; }
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _plexSecretStore = plexSecretStore;
+        _plexServerApiClient = plexServerApiClient;
+        _logger = logger;
+        _searchIndex = searchIndex;
     }
-}
+
+    public Task<Either<BaseError, Unit>> Handle(
+        SynchronizePlexLibraries request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(SynchronizeLibraries)
+            .Bind(v => v.ToEitherAsync());
+
+    private Task<Validation<BaseError, ConnectionParameters>> Validate(SynchronizePlexLibraries request) =>
+        MediaSourceMustExist(request)
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveToken);
+
+    private Task<Validation<BaseError, PlexMediaSource>> MediaSourceMustExist(SynchronizePlexLibraries request) =>
+        _mediaSourceRepository.GetPlex(request.PlexMediaSourceId)
+            .Map(o => o.ToValidation<BaseError>("Plex media source does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        PlexMediaSource plexMediaSource)
+    {
+        Option<PlexConnection> maybeConnection =
+            plexMediaSource.Connections.SingleOrDefault(c => c.IsActive);
+        return maybeConnection.Map(connection => new ConnectionParameters(plexMediaSource, connection))
+            .ToValidation<BaseError>("Plex media source requires an active connection");
+    }
+
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveToken(
+        ConnectionParameters connectionParameters)
+    {
+        Option<PlexServerAuthToken> maybeToken = await
+            _plexSecretStore.GetServerAuthToken(connectionParameters.PlexMediaSource.ClientIdentifier);
+        return maybeToken.Map(token => connectionParameters with { PlexServerAuthToken = token })
+            .ToValidation<BaseError>("Plex media source requires a token");
+    }
+
+    private async Task<Unit> SynchronizeLibraries(ConnectionParameters connectionParameters)
+    {
+        Either<BaseError, List<PlexLibrary>> maybeLibraries = await _plexServerApiClient.GetLibraries(
+            connectionParameters.ActiveConnection,
+            connectionParameters.PlexServerAuthToken);
+
+        await maybeLibraries.Match(
+            async libraries =>
+            {
+                var existing = connectionParameters.PlexMediaSource.Libraries.OfType<PlexLibrary>().ToList();
+                var toAdd = libraries.Filter(library => existing.All(l => l.Key != library.Key)).ToList();
+                var toRemove = existing.Filter(library => libraries.All(l => l.Key != library.Key)).ToList();
+                List<int> ids = await _mediaSourceRepository.UpdateLibraries(
+                    connectionParameters.PlexMediaSource.Id,
+                    toAdd,
+                    toRemove);
+                if (ids.Any())
+                {
+                    await _searchIndex.RemoveItems(ids);
+                    _searchIndex.Commit();
+                }
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Unable to synchronize libraries from plex server {PlexServer}: {Error}",
+                    connectionParameters.PlexMediaSource.ServerName,
+                    error.Value);
+
+                return Task.CompletedTask;
+            });
+
+        return Unit.Default;
+    }
+
+    private record ConnectionParameters(
+        PlexMediaSource PlexMediaSource,
+        PlexConnection ActiveConnection)
+    {
+        public PlexServerAuthToken PlexServerAuthToken { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryById.cs b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryById.cs
index 4a979d047..1192f8d50 100644
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryById.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryById.cs
@@ -1,24 +1,21 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public interface ISynchronizePlexLibraryById : IRequest<Either<BaseError, string>>, IPlexBackgroundServiceRequest
 {
-    public interface ISynchronizePlexLibraryById : IRequest<Either<BaseError, string>>, IPlexBackgroundServiceRequest
-    {
-        int PlexLibraryId { get; }
-        bool ForceScan { get; }
-    }
-
-    public record SynchronizePlexLibraryByIdIfNeeded
-        (int PlexLibraryId) : ISynchronizePlexLibraryById
-    {
-        public bool ForceScan => false;
-    }
-
-    public record ForceSynchronizePlexLibraryById
-        (int PlexLibraryId) : ISynchronizePlexLibraryById
-    {
-        public bool ForceScan => true;
-    }
+    int PlexLibraryId { get; }
+    bool ForceScan { get; }
 }
+
+public record SynchronizePlexLibraryByIdIfNeeded
+    (int PlexLibraryId) : ISynchronizePlexLibraryById
+{
+    public bool ForceScan => false;
+}
+
+public record ForceSynchronizePlexLibraryById
+    (int PlexLibraryId) : ISynchronizePlexLibraryById
+{
+    public bool ForceScan => true;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs
index 49b1a91ae..5cd0d2a04 100644
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs
@@ -1,176 +1,167 @@
-using System;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public class
+    SynchronizePlexLibraryByIdHandler : IRequestHandler<ForceSynchronizePlexLibraryById, Either<BaseError, string>>,
+        IRequestHandler<SynchronizePlexLibraryByIdIfNeeded, Either<BaseError, string>>
 {
-    public class
-        SynchronizePlexLibraryByIdHandler : IRequestHandler<ForceSynchronizePlexLibraryById, Either<BaseError, string>>,
-            IRequestHandler<SynchronizePlexLibraryByIdIfNeeded, Either<BaseError, string>>
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly IEntityLocker _entityLocker;
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILogger<SynchronizePlexLibraryByIdHandler> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IPlexMovieLibraryScanner _plexMovieLibraryScanner;
+    private readonly IPlexSecretStore _plexSecretStore;
+    private readonly IPlexTelevisionLibraryScanner _plexTelevisionLibraryScanner;
+
+    public SynchronizePlexLibraryByIdHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IConfigElementRepository configElementRepository,
+        IPlexSecretStore plexSecretStore,
+        IPlexMovieLibraryScanner plexMovieLibraryScanner,
+        IPlexTelevisionLibraryScanner plexTelevisionLibraryScanner,
+        ILibraryRepository libraryRepository,
+        IEntityLocker entityLocker,
+        ILogger<SynchronizePlexLibraryByIdHandler> logger)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly IEntityLocker _entityLocker;
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILogger<SynchronizePlexLibraryByIdHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IPlexMovieLibraryScanner _plexMovieLibraryScanner;
-        private readonly IPlexSecretStore _plexSecretStore;
-        private readonly IPlexTelevisionLibraryScanner _plexTelevisionLibraryScanner;
-
-        public SynchronizePlexLibraryByIdHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IConfigElementRepository configElementRepository,
-            IPlexSecretStore plexSecretStore,
-            IPlexMovieLibraryScanner plexMovieLibraryScanner,
-            IPlexTelevisionLibraryScanner plexTelevisionLibraryScanner,
-            ILibraryRepository libraryRepository,
-            IEntityLocker entityLocker,
-            ILogger<SynchronizePlexLibraryByIdHandler> logger)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _configElementRepository = configElementRepository;
-            _plexSecretStore = plexSecretStore;
-            _plexMovieLibraryScanner = plexMovieLibraryScanner;
-            _plexTelevisionLibraryScanner = plexTelevisionLibraryScanner;
-            _libraryRepository = libraryRepository;
-            _entityLocker = entityLocker;
-            _logger = logger;
-        }
-
-        public Task<Either<BaseError, string>> Handle(
-            ForceSynchronizePlexLibraryById request,
-            CancellationToken cancellationToken) => Handle(request);
-
-        public Task<Either<BaseError, string>> Handle(
-            SynchronizePlexLibraryByIdIfNeeded request,
-            CancellationToken cancellationToken) => Handle(request);
-
-        private Task<Either<BaseError, string>>
-            Handle(ISynchronizePlexLibraryById request) =>
-            Validate(request)
-                .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
-                .Bind(v => v.ToEitherAsync());
-
-        private async Task<Unit> Synchronize(RequestParameters parameters)
-        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
-            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
-            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
-            {
-                switch (parameters.Library.MediaKind)
-                {
-                    case LibraryMediaKind.Movies:
-                        await _plexMovieLibraryScanner.ScanLibrary(
-                            parameters.ConnectionParameters.ActiveConnection,
-                            parameters.ConnectionParameters.PlexServerAuthToken,
-                            parameters.Library,
-                            parameters.FFprobePath);
-                        break;
-                    case LibraryMediaKind.Shows:
-                        await _plexTelevisionLibraryScanner.ScanLibrary(
-                            parameters.ConnectionParameters.ActiveConnection,
-                            parameters.ConnectionParameters.PlexServerAuthToken,
-                            parameters.Library,
-                            parameters.FFprobePath);
-                        break;
-                }
-
-                parameters.Library.LastScan = DateTime.UtcNow;
-                await _libraryRepository.UpdateLastScan(parameters.Library);
-            }
-            else
-            {
-                _logger.LogDebug(
-                    "Skipping unforced scan of plex media library {Name}",
-                    parameters.Library.Name);
-            }
-
-            _entityLocker.UnlockLibrary(parameters.Library.Id);
-            return Unit.Default;
-        }
-
-        private async Task<Validation<BaseError, RequestParameters>> Validate(ISynchronizePlexLibraryById request) =>
-            (await ValidateConnection(request), await PlexLibraryMustExist(request),
-                await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
-            .Apply(
-                (connectionParameters, plexLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
-                    connectionParameters,
-                    plexLibrary,
-                    request.ForceScan,
-                    libraryRefreshInterval,
-                    ffprobePath
-                ));
-
-        private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
-            ISynchronizePlexLibraryById request) =>
-            PlexMediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveToken);
-
-        private Task<Validation<BaseError, PlexMediaSource>> PlexMediaSourceMustExist(
-            ISynchronizePlexLibraryById request) =>
-            _mediaSourceRepository.GetPlexByLibraryId(request.PlexLibraryId)
-                .Map(
-                    v => v.ToValidation<BaseError>(
-                        $"Plex media source for library {request.PlexLibraryId} does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            PlexMediaSource plexMediaSource)
-        {
-            Option<PlexConnection> maybeConnection =
-                plexMediaSource.Connections.SingleOrDefault(c => c.IsActive);
-            return maybeConnection.Map(connection => new ConnectionParameters(plexMediaSource, connection))
-                .ToValidation<BaseError>("Plex media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveToken(
-            ConnectionParameters connectionParameters)
-        {
-            Option<PlexServerAuthToken> maybeToken = await
-                _plexSecretStore.GetServerAuthToken(connectionParameters.PlexMediaSource.ClientIdentifier);
-            return maybeToken.Map(token => connectionParameters with { PlexServerAuthToken = token })
-                .ToValidation<BaseError>("Plex media source requires a token");
-        }
-
-        private Task<Validation<BaseError, PlexLibrary>> PlexLibraryMustExist(
-            ISynchronizePlexLibraryById request) =>
-            _mediaSourceRepository.GetPlexLibrary(request.PlexLibraryId)
-                .Map(v => v.ToValidation<BaseError>($"Plex library {request.PlexLibraryId} does not exist."));
-
-        private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
-            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
-                .FilterT(lri => lri > 0)
-                .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
-        
-        private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
-            _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
-                .FilterT(File.Exists)
-                .Map(
-                    ffprobePath =>
-                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
-
-        private record RequestParameters(
-            ConnectionParameters ConnectionParameters,
-            PlexLibrary Library,
-            bool ForceScan,
-            int LibraryRefreshInterval,
-            string FFprobePath);
-
-        private record ConnectionParameters(PlexMediaSource PlexMediaSource, PlexConnection ActiveConnection)
-        {
-            public PlexServerAuthToken PlexServerAuthToken { get; set; }
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _configElementRepository = configElementRepository;
+        _plexSecretStore = plexSecretStore;
+        _plexMovieLibraryScanner = plexMovieLibraryScanner;
+        _plexTelevisionLibraryScanner = plexTelevisionLibraryScanner;
+        _libraryRepository = libraryRepository;
+        _entityLocker = entityLocker;
+        _logger = logger;
     }
-}
+
+    public Task<Either<BaseError, string>> Handle(
+        ForceSynchronizePlexLibraryById request,
+        CancellationToken cancellationToken) => Handle(request);
+
+    public Task<Either<BaseError, string>> Handle(
+        SynchronizePlexLibraryByIdIfNeeded request,
+        CancellationToken cancellationToken) => Handle(request);
+
+    private Task<Either<BaseError, string>>
+        Handle(ISynchronizePlexLibraryById request) =>
+        Validate(request)
+            .MapT(parameters => Synchronize(parameters).Map(_ => parameters.Library.Name))
+            .Bind(v => v.ToEitherAsync());
+
+    private async Task<Unit> Synchronize(RequestParameters parameters)
+    {
+        var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
+        DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
+        if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
+        {
+            switch (parameters.Library.MediaKind)
+            {
+                case LibraryMediaKind.Movies:
+                    await _plexMovieLibraryScanner.ScanLibrary(
+                        parameters.ConnectionParameters.ActiveConnection,
+                        parameters.ConnectionParameters.PlexServerAuthToken,
+                        parameters.Library,
+                        parameters.FFprobePath);
+                    break;
+                case LibraryMediaKind.Shows:
+                    await _plexTelevisionLibraryScanner.ScanLibrary(
+                        parameters.ConnectionParameters.ActiveConnection,
+                        parameters.ConnectionParameters.PlexServerAuthToken,
+                        parameters.Library,
+                        parameters.FFprobePath);
+                    break;
+            }
+
+            parameters.Library.LastScan = DateTime.UtcNow;
+            await _libraryRepository.UpdateLastScan(parameters.Library);
+        }
+        else
+        {
+            _logger.LogDebug(
+                "Skipping unforced scan of plex media library {Name}",
+                parameters.Library.Name);
+        }
+
+        _entityLocker.UnlockLibrary(parameters.Library.Id);
+        return Unit.Default;
+    }
+
+    private async Task<Validation<BaseError, RequestParameters>> Validate(ISynchronizePlexLibraryById request) =>
+        (await ValidateConnection(request), await PlexLibraryMustExist(request),
+            await ValidateLibraryRefreshInterval(), await ValidateFFprobePath())
+        .Apply(
+            (connectionParameters, plexLibrary, libraryRefreshInterval, ffprobePath) => new RequestParameters(
+                connectionParameters,
+                plexLibrary,
+                request.ForceScan,
+                libraryRefreshInterval,
+                ffprobePath
+            ));
+
+    private Task<Validation<BaseError, ConnectionParameters>> ValidateConnection(
+        ISynchronizePlexLibraryById request) =>
+        PlexMediaSourceMustExist(request)
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveToken);
+
+    private Task<Validation<BaseError, PlexMediaSource>> PlexMediaSourceMustExist(
+        ISynchronizePlexLibraryById request) =>
+        _mediaSourceRepository.GetPlexByLibraryId(request.PlexLibraryId)
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    $"Plex media source for library {request.PlexLibraryId} does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        PlexMediaSource plexMediaSource)
+    {
+        Option<PlexConnection> maybeConnection =
+            plexMediaSource.Connections.SingleOrDefault(c => c.IsActive);
+        return maybeConnection.Map(connection => new ConnectionParameters(plexMediaSource, connection))
+            .ToValidation<BaseError>("Plex media source requires an active connection");
+    }
+
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveToken(
+        ConnectionParameters connectionParameters)
+    {
+        Option<PlexServerAuthToken> maybeToken = await
+            _plexSecretStore.GetServerAuthToken(connectionParameters.PlexMediaSource.ClientIdentifier);
+        return maybeToken.Map(token => connectionParameters with { PlexServerAuthToken = token })
+            .ToValidation<BaseError>("Plex media source requires a token");
+    }
+
+    private Task<Validation<BaseError, PlexLibrary>> PlexLibraryMustExist(
+        ISynchronizePlexLibraryById request) =>
+        _mediaSourceRepository.GetPlexLibrary(request.PlexLibraryId)
+            .Map(v => v.ToValidation<BaseError>($"Plex library {request.PlexLibraryId} does not exist."));
+
+    private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
+        _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+            .FilterT(lri => lri > 0)
+            .Map(lri => lri.ToValidation<BaseError>("Library refresh interval is invalid"));
+        
+    private Task<Validation<BaseError, string>> ValidateFFprobePath() =>
+        _configElementRepository.GetValue<string>(ConfigElementKey.FFprobePath)
+            .FilterT(File.Exists)
+            .Map(
+                ffprobePath =>
+                    ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));
+
+    private record RequestParameters(
+        ConnectionParameters ConnectionParameters,
+        PlexLibrary Library,
+        bool ForceScan,
+        int LibraryRefreshInterval,
+        string FFprobePath);
+
+    private record ConnectionParameters(PlexMediaSource PlexMediaSource, PlexConnection ActiveConnection)
+    {
+        public PlexServerAuthToken PlexServerAuthToken { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSources.cs b/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSources.cs
index c1c7680a5..83da2a37a 100644
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSources.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSources.cs
@@ -1,11 +1,7 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Plex.Commands
-{
-    public record
-        SynchronizePlexMediaSources : IRequest<Either<BaseError, List<PlexMediaSource>>>, IPlexBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Plex;
+
+public record
+    SynchronizePlexMediaSources : IRequest<Either<BaseError, List<PlexMediaSource>>>, IPlexBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs b/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs
index b524991a1..4552769ed 100644
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs
@@ -1,151 +1,144 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public class
+    SynchronizePlexMediaSourcesHandler : IRequestHandler<SynchronizePlexMediaSources,
+        Either<BaseError, List<PlexMediaSource>>>
 {
-    public class
-        SynchronizePlexMediaSourcesHandler : IRequestHandler<SynchronizePlexMediaSources,
-            Either<BaseError, List<PlexMediaSource>>>
+    private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
+    private readonly IEntityLocker _entityLocker;
+    private readonly ILogger<SynchronizePlexMediaSourcesHandler> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IPlexTvApiClient _plexTvApiClient;
+    private readonly IPlexServerApiClient _plexServerApiClient;
+    private readonly IPlexSecretStore _plexSecretStore;
+
+    public SynchronizePlexMediaSourcesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        IPlexTvApiClient plexTvApiClient,
+        IPlexServerApiClient plexServerApiClient,
+        IPlexSecretStore plexSecretStore,
+        ChannelWriter<IPlexBackgroundServiceRequest> channel,
+        IEntityLocker entityLocker,
+        ILogger<SynchronizePlexMediaSourcesHandler> logger)
     {
-        private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
-        private readonly IEntityLocker _entityLocker;
-        private readonly ILogger<SynchronizePlexMediaSourcesHandler> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IPlexTvApiClient _plexTvApiClient;
-        private readonly IPlexServerApiClient _plexServerApiClient;
-        private readonly IPlexSecretStore _plexSecretStore;
+        _mediaSourceRepository = mediaSourceRepository;
+        _plexTvApiClient = plexTvApiClient;
+        _plexServerApiClient = plexServerApiClient;
+        _plexSecretStore = plexSecretStore;
+        _channel = channel;
+        _entityLocker = entityLocker;
+        _logger = logger;
+    }
 
-        public SynchronizePlexMediaSourcesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            IPlexTvApiClient plexTvApiClient,
-            IPlexServerApiClient plexServerApiClient,
-            IPlexSecretStore plexSecretStore,
-            ChannelWriter<IPlexBackgroundServiceRequest> channel,
-            IEntityLocker entityLocker,
-            ILogger<SynchronizePlexMediaSourcesHandler> logger)
+    public Task<Either<BaseError, List<PlexMediaSource>>> Handle(
+        SynchronizePlexMediaSources request,
+        CancellationToken cancellationToken) => _plexTvApiClient.GetServers().BindAsync(SynchronizeAllServers);
+
+    private async Task<Either<BaseError, List<PlexMediaSource>>> SynchronizeAllServers(
+        List<PlexMediaSource> servers)
+    {
+        List<PlexMediaSource> allExisting = await _mediaSourceRepository.GetAllPlex();
+        foreach (PlexMediaSource server in servers)
         {
-            _mediaSourceRepository = mediaSourceRepository;
-            _plexTvApiClient = plexTvApiClient;
-            _plexServerApiClient = plexServerApiClient;
-            _plexSecretStore = plexSecretStore;
-            _channel = channel;
-            _entityLocker = entityLocker;
-            _logger = logger;
+            await SynchronizeServer(allExisting, server);
         }
 
-        public Task<Either<BaseError, List<PlexMediaSource>>> Handle(
-            SynchronizePlexMediaSources request,
-            CancellationToken cancellationToken) => _plexTvApiClient.GetServers().BindAsync(SynchronizeAllServers);
-
-        private async Task<Either<BaseError, List<PlexMediaSource>>> SynchronizeAllServers(
-            List<PlexMediaSource> servers)
+        // delete removed servers
+        foreach (PlexMediaSource removed in allExisting.Filter(
+                     s => servers.All(pms => pms.ClientIdentifier != s.ClientIdentifier)))
         {
-            List<PlexMediaSource> allExisting = await _mediaSourceRepository.GetAllPlex();
-            foreach (PlexMediaSource server in servers)
-            {
-                await SynchronizeServer(allExisting, server);
-            }
-
-            // delete removed servers
-            foreach (PlexMediaSource removed in allExisting.Filter(
-                s => servers.All(pms => pms.ClientIdentifier != s.ClientIdentifier)))
-            {
-                _logger.LogWarning("Deleting removed Plex server {ServerName}!", removed.Id.ToString());
-                await _mediaSourceRepository.DeletePlex(removed);
-            }
-
-            foreach (PlexMediaSource mediaSource in await _mediaSourceRepository.GetAllPlex())
-            {
-                await _channel.WriteAsync(new SynchronizePlexLibraries(mediaSource.Id));
-            }
-
-            _entityLocker.UnlockPlex();
-
-            return allExisting;
+            _logger.LogWarning("Deleting removed Plex server {ServerName}!", removed.Id.ToString());
+            await _mediaSourceRepository.DeletePlex(removed);
         }
 
-        private async Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
+        foreach (PlexMediaSource mediaSource in await _mediaSourceRepository.GetAllPlex())
         {
-            Option<PlexMediaSource> maybeExisting =
-                allExisting.Find(s => s.ClientIdentifier == server.ClientIdentifier);
-
-            foreach (PlexMediaSource existing in maybeExisting)
-            {
-                existing.Platform = server.Platform;
-                existing.PlatformVersion = server.PlatformVersion;
-                existing.ProductVersion = server.ProductVersion;
-                existing.ServerName = server.ServerName;
-                var toAdd = server.Connections
-                    .Filter(connection => existing.Connections.All(c => c.Uri != connection.Uri)).ToList();
-                var toRemove = existing.Connections
-                    .Filter(connection => server.Connections.All(c => c.Uri != connection.Uri)).ToList();
-                await _mediaSourceRepository.Update(existing, toAdd, toRemove);
-                await FindConnectionToActivate(existing);
-            }
-
-            if (maybeExisting.IsNone)
-            {
-                await _mediaSourceRepository.Add(server);
-                await FindConnectionToActivate(server);
-            }
+            await _channel.WriteAsync(new SynchronizePlexLibraries(mediaSource.Id));
         }
 
-        private async Task FindConnectionToActivate(PlexMediaSource server)
+        _entityLocker.UnlockPlex();
+
+        return allExisting;
+    }
+
+    private async Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
+    {
+        Option<PlexMediaSource> maybeExisting =
+            allExisting.Find(s => s.ClientIdentifier == server.ClientIdentifier);
+
+        foreach (PlexMediaSource existing in maybeExisting)
         {
-            var prioritized = server.Connections.OrderBy(pc => pc.IsActive ? 0 : 1).ToList();
-            foreach (PlexConnection connection in server.Connections)
-            {
-                connection.IsActive = false;
-            }
+            existing.Platform = server.Platform;
+            existing.PlatformVersion = server.PlatformVersion;
+            existing.ProductVersion = server.ProductVersion;
+            existing.ServerName = server.ServerName;
+            var toAdd = server.Connections
+                .Filter(connection => existing.Connections.All(c => c.Uri != connection.Uri)).ToList();
+            var toRemove = existing.Connections
+                .Filter(connection => server.Connections.All(c => c.Uri != connection.Uri)).ToList();
+            await _mediaSourceRepository.Update(existing, toAdd, toRemove);
+            await FindConnectionToActivate(existing);
+        }
 
-            Option<PlexServerAuthToken> maybeToken = await _plexSecretStore.GetServerAuthToken(server.ClientIdentifier);
-            foreach (PlexServerAuthToken token in maybeToken)
-            {
-                foreach (PlexConnection connection in prioritized)
-                {
-                    try
-                    {
-                        _logger.LogDebug("Attempting to locate to Plex at {Uri}", connection.Uri);
-                        if (await _plexServerApiClient.Ping(connection, token))
-                        {
-                            _logger.LogInformation("Located Plex at {Uri}", connection.Uri);
-                            connection.IsActive = true;
-                            break;
-                        }
-                    }
-                    catch
-                    {
-                        // do nothing
-                    }
-                }
-            }
-
-            if (maybeToken.IsNone)
-            {
-                _logger.LogError(
-                    "Unable to activate Plex connection for server {Server} without auth token",
-                    server.ServerName);
-            }
-
-            if (server.Connections.All(c => !c.IsActive))
-            {
-                _logger.LogError("Unable to locate Plex");
-                server.Connections.Head().IsActive = true;
-            }
-
-            await _mediaSourceRepository.Update(server, new List<PlexConnection>(), new List<PlexConnection>());
+        if (maybeExisting.IsNone)
+        {
+            await _mediaSourceRepository.Add(server);
+            await FindConnectionToActivate(server);
         }
     }
-}
+
+    private async Task FindConnectionToActivate(PlexMediaSource server)
+    {
+        var prioritized = server.Connections.OrderBy(pc => pc.IsActive ? 0 : 1).ToList();
+        foreach (PlexConnection connection in server.Connections)
+        {
+            connection.IsActive = false;
+        }
+
+        Option<PlexServerAuthToken> maybeToken = await _plexSecretStore.GetServerAuthToken(server.ClientIdentifier);
+        foreach (PlexServerAuthToken token in maybeToken)
+        {
+            foreach (PlexConnection connection in prioritized)
+            {
+                try
+                {
+                    _logger.LogDebug("Attempting to locate to Plex at {Uri}", connection.Uri);
+                    if (await _plexServerApiClient.Ping(connection, token))
+                    {
+                        _logger.LogInformation("Located Plex at {Uri}", connection.Uri);
+                        connection.IsActive = true;
+                        break;
+                    }
+                }
+                catch
+                {
+                    // do nothing
+                }
+            }
+        }
+
+        if (maybeToken.IsNone)
+        {
+            _logger.LogError(
+                "Unable to activate Plex connection for server {Server} without auth token",
+                server.ServerName);
+        }
+
+        if (server.Connections.All(c => !c.IsActive))
+        {
+            _logger.LogError("Unable to locate Plex");
+            server.Connections.Head().IsActive = true;
+        }
+
+        await _mediaSourceRepository.Update(server, new List<PlexConnection>(), new List<PlexConnection>());
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/TryCompletePlexPinFlow.cs b/ErsatzTV.Application/Plex/Commands/TryCompletePlexPinFlow.cs
index 97dc66389..00d3fa4d0 100644
--- a/ErsatzTV.Application/Plex/Commands/TryCompletePlexPinFlow.cs
+++ b/ErsatzTV.Application/Plex/Commands/TryCompletePlexPinFlow.cs
@@ -1,10 +1,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Plex.Commands
-{
-    public record TryCompletePlexPinFlow(PlexAuthPin AuthPin) : IRequest<Either<BaseError, bool>>,
-        IPlexBackgroundServiceRequest;
-}
+namespace ErsatzTV.Application.Plex;
+
+public record TryCompletePlexPinFlow(PlexAuthPin AuthPin) : IRequest<Either<BaseError, bool>>,
+    IPlexBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/TryCompletePlexPinFlowHandler.cs b/ErsatzTV.Application/Plex/Commands/TryCompletePlexPinFlowHandler.cs
index c8f535b29..b283695e1 100644
--- a/ErsatzTV.Application/Plex/Commands/TryCompletePlexPinFlowHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/TryCompletePlexPinFlowHandler.cs
@@ -1,45 +1,39 @@
-using System;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Plex;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public class TryCompletePlexPinFlowHandler : IRequestHandler<TryCompletePlexPinFlow, Either<BaseError, bool>>
 {
-    public class TryCompletePlexPinFlowHandler : IRequestHandler<TryCompletePlexPinFlow, Either<BaseError, bool>>
+    private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
+    private readonly IPlexTvApiClient _plexTvApiClient;
+
+    public TryCompletePlexPinFlowHandler(
+        IPlexTvApiClient plexTvApiClient,
+        ChannelWriter<IPlexBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IPlexBackgroundServiceRequest> _channel;
-        private readonly IPlexTvApiClient _plexTvApiClient;
+        _plexTvApiClient = plexTvApiClient;
+        _channel = channel;
+    }
 
-        public TryCompletePlexPinFlowHandler(
-            IPlexTvApiClient plexTvApiClient,
-            ChannelWriter<IPlexBackgroundServiceRequest> channel)
+    public async Task<Either<BaseError, bool>>
+        Handle(TryCompletePlexPinFlow request, CancellationToken cancellationToken)
+    {
+        var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2));
+        CancellationToken token = cts.Token;
+        while (!token.IsCancellationRequested)
         {
-            _plexTvApiClient = plexTvApiClient;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, bool>>
-            Handle(TryCompletePlexPinFlow request, CancellationToken cancellationToken)
-        {
-            var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2));
-            CancellationToken token = cts.Token;
-            while (!token.IsCancellationRequested)
+            bool result = await _plexTvApiClient.TryCompletePinFlow(request.AuthPin);
+            if (result)
             {
-                bool result = await _plexTvApiClient.TryCompletePinFlow(request.AuthPin);
-                if (result)
-                {
-                    await _channel.WriteAsync(new SynchronizePlexMediaSources(), cancellationToken);
-                    return true;
-                }
-
-                await Task.Delay(TimeSpan.FromSeconds(1), token);
+                await _channel.WriteAsync(new SynchronizePlexMediaSources(), cancellationToken);
+                return true;
             }
 
-            return false;
+            await Task.Delay(TimeSpan.FromSeconds(1), token);
         }
+
+        return false;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferences.cs b/ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferences.cs
index 244c15f8d..57dcb40f1 100644
--- a/ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferences.cs
+++ b/ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferences.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Plex.Commands
-{
-    public record UpdatePlexLibraryPreferences
-        (List<PlexLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+namespace ErsatzTV.Application.Plex;
 
-    public record PlexLibraryPreference(int Id, bool ShouldSyncItems);
-}
+public record UpdatePlexLibraryPreferences
+    (List<PlexLibraryPreference> Preferences) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+public record PlexLibraryPreference(int Id, bool ShouldSyncItems);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferencesHandler.cs b/ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferencesHandler.cs
index fdd3355d1..ddc24f837 100644
--- a/ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferencesHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/UpdatePlexLibraryPreferencesHandler.cs
@@ -1,42 +1,36 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public class
+    UpdatePlexLibraryPreferencesHandler : MediatR.IRequestHandler<UpdatePlexLibraryPreferences,
+        Either<BaseError, Unit>>
 {
-    public class
-        UpdatePlexLibraryPreferencesHandler : MediatR.IRequestHandler<UpdatePlexLibraryPreferences,
-            Either<BaseError, Unit>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public UpdatePlexLibraryPreferencesHandler(
+        IMediaSourceRepository mediaSourceRepository,
+        ISearchIndex searchIndex)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public UpdatePlexLibraryPreferencesHandler(
-            IMediaSourceRepository mediaSourceRepository,
-            ISearchIndex searchIndex)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _searchIndex = searchIndex;
-        }
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            UpdatePlexLibraryPreferences request,
-            CancellationToken cancellationToken)
-        {
-            var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
-            List<int> ids = await _mediaSourceRepository.DisablePlexLibrarySync(toDisable);
-            await _searchIndex.RemoveItems(ids);
-            _searchIndex.Commit();
-
-            IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
-            await _mediaSourceRepository.EnablePlexLibrarySync(toEnable);
-
-            return Unit.Default;
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _searchIndex = searchIndex;
     }
-}
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        UpdatePlexLibraryPreferences request,
+        CancellationToken cancellationToken)
+    {
+        var toDisable = request.Preferences.Filter(p => p.ShouldSyncItems == false).Map(p => p.Id).ToList();
+        List<int> ids = await _mediaSourceRepository.DisablePlexLibrarySync(toDisable);
+        await _searchIndex.RemoveItems(ids);
+        _searchIndex.Commit();
+
+        IEnumerable<int> toEnable = request.Preferences.Filter(p => p.ShouldSyncItems).Map(p => p.Id);
+        await _mediaSourceRepository.EnablePlexLibrarySync(toEnable);
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacements.cs b/ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacements.cs
index cb4319e02..54e5306f7 100644
--- a/ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacements.cs
+++ b/ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacements.cs
@@ -1,13 +1,10 @@
-using System.Collections.Generic;
-using ErsatzTV.Core;
-using LanguageExt;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Plex.Commands
-{
-    public record UpdatePlexPathReplacements
-    (
-        int PlexMediaSourceId,
-        List<PlexPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+namespace ErsatzTV.Application.Plex;
 
-    public record PlexPathReplacementItem(int Id, string PlexPath, string LocalPath);
-}
+public record UpdatePlexPathReplacements
+(
+    int PlexMediaSourceId,
+    List<PlexPathReplacementItem> PathReplacements) : MediatR.IRequest<Either<BaseError, Unit>>;
+
+public record PlexPathReplacementItem(int Id, string PlexPath, string LocalPath);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacementsHandler.cs b/ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacementsHandler.cs
index 67f469523..3c7036384 100644
--- a/ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacementsHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/UpdatePlexPathReplacementsHandler.cs
@@ -1,51 +1,45 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Plex.Commands
+namespace ErsatzTV.Application.Plex;
+
+public class
+    UpdatePlexPathReplacementsHandler : MediatR.IRequestHandler<UpdatePlexPathReplacements, Either<BaseError, Unit>>
 {
-    public class
-        UpdatePlexPathReplacementsHandler : MediatR.IRequestHandler<UpdatePlexPathReplacements, Either<BaseError, Unit>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+
+    public UpdatePlexPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
+
+    public Task<Either<BaseError, Unit>> Handle(
+        UpdatePlexPathReplacements request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(pms => MergePathReplacements(request, pms))
+            .Bind(v => v.ToEitherAsync());
+
+    private Task<Unit> MergePathReplacements(UpdatePlexPathReplacements request, PlexMediaSource plexMediaSource)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+        plexMediaSource.PathReplacements ??= new List<PlexPathReplacement>();
 
-        public UpdatePlexPathReplacementsHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+        var incoming = request.PathReplacements.Map(Project).ToList();
 
-        public Task<Either<BaseError, Unit>> Handle(
-            UpdatePlexPathReplacements request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(pms => MergePathReplacements(request, pms))
-                .Bind(v => v.ToEitherAsync());
+        var toAdd = incoming.Filter(r => r.Id < 1).ToList();
+        var toRemove = plexMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
+        var toUpdate = incoming.Except(toAdd).ToList();
 
-        private Task<Unit> MergePathReplacements(UpdatePlexPathReplacements request, PlexMediaSource plexMediaSource)
-        {
-            plexMediaSource.PathReplacements ??= new List<PlexPathReplacement>();
-
-            var incoming = request.PathReplacements.Map(Project).ToList();
-
-            var toAdd = incoming.Filter(r => r.Id < 1).ToList();
-            var toRemove = plexMediaSource.PathReplacements.Filter(r => incoming.All(pr => pr.Id != r.Id)).ToList();
-            var toUpdate = incoming.Except(toAdd).ToList();
-
-            return _mediaSourceRepository.UpdatePathReplacements(plexMediaSource.Id, toAdd, toUpdate, toRemove);
-        }
-
-        private static PlexPathReplacement Project(PlexPathReplacementItem vm) =>
-            new() { Id = vm.Id, PlexPath = vm.PlexPath, LocalPath = vm.LocalPath };
-
-        private Task<Validation<BaseError, PlexMediaSource>> Validate(UpdatePlexPathReplacements request) =>
-            PlexMediaSourceMustExist(request);
-
-        private Task<Validation<BaseError, PlexMediaSource>> PlexMediaSourceMustExist(
-            UpdatePlexPathReplacements request) =>
-            _mediaSourceRepository.GetPlex(request.PlexMediaSourceId)
-                .Map(v => v.ToValidation<BaseError>($"Plex media source {request.PlexMediaSourceId} does not exist."));
+        return _mediaSourceRepository.UpdatePathReplacements(plexMediaSource.Id, toAdd, toUpdate, toRemove);
     }
-}
+
+    private static PlexPathReplacement Project(PlexPathReplacementItem vm) =>
+        new() { Id = vm.Id, PlexPath = vm.PlexPath, LocalPath = vm.LocalPath };
+
+    private Task<Validation<BaseError, PlexMediaSource>> Validate(UpdatePlexPathReplacements request) =>
+        PlexMediaSourceMustExist(request);
+
+    private Task<Validation<BaseError, PlexMediaSource>> PlexMediaSourceMustExist(
+        UpdatePlexPathReplacements request) =>
+        _mediaSourceRepository.GetPlex(request.PlexMediaSourceId)
+            .Map(v => v.ToValidation<BaseError>($"Plex media source {request.PlexMediaSourceId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Mapper.cs b/ErsatzTV.Application/Plex/Mapper.cs
index c8b2a1d37..55f23ed17 100644
--- a/ErsatzTV.Application/Plex/Mapper.cs
+++ b/ErsatzTV.Application/Plex/Mapper.cs
@@ -1,21 +1,18 @@
-using System.Linq;
-using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Plex
+namespace ErsatzTV.Application.Plex;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static PlexMediaSourceViewModel ProjectToViewModel(PlexMediaSource plexMediaSource) =>
-            new(
-                plexMediaSource.Id,
-                plexMediaSource.ServerName,
-                Optional(plexMediaSource.Connections.SingleOrDefault(c => c.IsActive)).Match(c => c.Uri, string.Empty));
+    internal static PlexMediaSourceViewModel ProjectToViewModel(PlexMediaSource plexMediaSource) =>
+        new(
+            plexMediaSource.Id,
+            plexMediaSource.ServerName,
+            Optional(plexMediaSource.Connections.SingleOrDefault(c => c.IsActive)).Match(c => c.Uri, string.Empty));
 
-        internal static PlexLibraryViewModel ProjectToViewModel(PlexLibrary library) =>
-            new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
+    internal static PlexLibraryViewModel ProjectToViewModel(PlexLibrary library) =>
+        new(library.Id, library.Name, library.MediaKind, library.ShouldSyncItems);
 
-        internal static PlexPathReplacementViewModel ProjectToViewModel(PlexPathReplacement pathReplacement) =>
-            new(pathReplacement.Id, pathReplacement.PlexPath, pathReplacement.LocalPath);
-    }
-}
+    internal static PlexPathReplacementViewModel ProjectToViewModel(PlexPathReplacement pathReplacement) =>
+        new(pathReplacement.Id, pathReplacement.PlexPath, pathReplacement.LocalPath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/PlexConnectionParametersViewModel.cs b/ErsatzTV.Application/Plex/PlexConnectionParametersViewModel.cs
index d01b17e50..eefa84c87 100644
--- a/ErsatzTV.Application/Plex/PlexConnectionParametersViewModel.cs
+++ b/ErsatzTV.Application/Plex/PlexConnectionParametersViewModel.cs
@@ -1,6 +1,3 @@
-using System;
+namespace ErsatzTV.Application.Plex;
 
-namespace ErsatzTV.Application.Plex
-{
-    public record PlexConnectionParametersViewModel(Uri Uri, string AuthToken);
-}
+public record PlexConnectionParametersViewModel(Uri Uri, string AuthToken);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/PlexLibraryViewModel.cs b/ErsatzTV.Application/Plex/PlexLibraryViewModel.cs
index d0dae98ee..f09ea9bb6 100644
--- a/ErsatzTV.Application/Plex/PlexLibraryViewModel.cs
+++ b/ErsatzTV.Application/Plex/PlexLibraryViewModel.cs
@@ -1,6 +1,5 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Plex
-{
-    public record PlexLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems);
-}
+namespace ErsatzTV.Application.Plex;
+
+public record PlexLibraryViewModel(int Id, string Name, LibraryMediaKind MediaKind, bool ShouldSyncItems);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/PlexMediaSourceViewModel.cs b/ErsatzTV.Application/Plex/PlexMediaSourceViewModel.cs
index a5567d43b..df86da4dd 100644
--- a/ErsatzTV.Application/Plex/PlexMediaSourceViewModel.cs
+++ b/ErsatzTV.Application/Plex/PlexMediaSourceViewModel.cs
@@ -1,6 +1,5 @@
 using ErsatzTV.Application.MediaSources;
 
-namespace ErsatzTV.Application.Plex
-{
-    public record PlexMediaSourceViewModel(int Id, string Name, string Address) : MediaSourceViewModel(Id, Name);
-}
+namespace ErsatzTV.Application.Plex;
+
+public record PlexMediaSourceViewModel(int Id, string Name, string Address) : MediaSourceViewModel(Id, Name);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/PlexPathReplacementViewModel.cs b/ErsatzTV.Application/Plex/PlexPathReplacementViewModel.cs
index a8809250c..266d60c2a 100644
--- a/ErsatzTV.Application/Plex/PlexPathReplacementViewModel.cs
+++ b/ErsatzTV.Application/Plex/PlexPathReplacementViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Plex
-{
-    public record PlexPathReplacementViewModel(int Id, string PlexPath, string LocalPath);
-}
+namespace ErsatzTV.Application.Plex;
+
+public record PlexPathReplacementViewModel(int Id, string PlexPath, string LocalPath);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetAllPlexMediaSources.cs b/ErsatzTV.Application/Plex/Queries/GetAllPlexMediaSources.cs
index c99fa95fc..81d0bd7c7 100644
--- a/ErsatzTV.Application/Plex/Queries/GetAllPlexMediaSources.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetAllPlexMediaSources.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Plex;
 
-namespace ErsatzTV.Application.Plex.Queries
-{
-    public record GetAllPlexMediaSources : IRequest<List<PlexMediaSourceViewModel>>;
-}
+public record GetAllPlexMediaSources : IRequest<List<PlexMediaSourceViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetAllPlexMediaSourcesHandler.cs b/ErsatzTV.Application/Plex/Queries/GetAllPlexMediaSourcesHandler.cs
index 22761238f..7bc40d26b 100644
--- a/ErsatzTV.Application/Plex/Queries/GetAllPlexMediaSourcesHandler.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetAllPlexMediaSourcesHandler.cs
@@ -1,24 +1,17 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Plex.Mapper;
 
-namespace ErsatzTV.Application.Plex.Queries
+namespace ErsatzTV.Application.Plex;
+
+public class GetAllPlexMediaSourcesHandler : IRequestHandler<GetAllPlexMediaSources, List<PlexMediaSourceViewModel>>
 {
-    public class GetAllPlexMediaSourcesHandler : IRequestHandler<GetAllPlexMediaSources, List<PlexMediaSourceViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetAllPlexMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetAllPlexMediaSourcesHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<PlexMediaSourceViewModel>> Handle(
-            GetAllPlexMediaSources request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetAllPlex().Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<PlexMediaSourceViewModel>> Handle(
+        GetAllPlexMediaSources request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetAllPlex().Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetPlexConnectionParameters.cs b/ErsatzTV.Application/Plex/Queries/GetPlexConnectionParameters.cs
index 3607ee8db..23cb87aa4 100644
--- a/ErsatzTV.Application/Plex/Queries/GetPlexConnectionParameters.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetPlexConnectionParameters.cs
@@ -1,9 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Plex.Queries
-{
-    public record GetPlexConnectionParameters
-        (int PlexMediaSourceId) : IRequest<Either<BaseError, PlexConnectionParametersViewModel>>;
-}
+namespace ErsatzTV.Application.Plex;
+
+public record GetPlexConnectionParameters
+    (int PlexMediaSourceId) : IRequest<Either<BaseError, PlexConnectionParametersViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetPlexConnectionParametersHandler.cs b/ErsatzTV.Application/Plex/Queries/GetPlexConnectionParametersHandler.cs
index 0ea0e867a..53f26f948 100644
--- a/ErsatzTV.Application/Plex/Queries/GetPlexConnectionParametersHandler.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetPlexConnectionParametersHandler.cs
@@ -1,94 +1,87 @@
-using System;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.Caching.Memory;
 
-namespace ErsatzTV.Application.Plex.Queries
+namespace ErsatzTV.Application.Plex;
+
+public class GetPlexConnectionParametersHandler : IRequestHandler<GetPlexConnectionParameters,
+    Either<BaseError, PlexConnectionParametersViewModel>>
 {
-    public class GetPlexConnectionParametersHandler : IRequestHandler<GetPlexConnectionParameters,
-        Either<BaseError, PlexConnectionParametersViewModel>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMemoryCache _memoryCache;
+    private readonly IPlexSecretStore _plexSecretStore;
+
+    public GetPlexConnectionParametersHandler(
+        IMemoryCache memoryCache,
+        IMediaSourceRepository mediaSourceRepository,
+        IPlexSecretStore plexSecretStore)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMemoryCache _memoryCache;
-        private readonly IPlexSecretStore _plexSecretStore;
-
-        public GetPlexConnectionParametersHandler(
-            IMemoryCache memoryCache,
-            IMediaSourceRepository mediaSourceRepository,
-            IPlexSecretStore plexSecretStore)
-        {
-            _memoryCache = memoryCache;
-            _mediaSourceRepository = mediaSourceRepository;
-            _plexSecretStore = plexSecretStore;
-        }
-
-        public async Task<Either<BaseError, PlexConnectionParametersViewModel>> Handle(
-            GetPlexConnectionParameters request,
-            CancellationToken cancellationToken)
-        {
-            if (_memoryCache.TryGetValue(request, out PlexConnectionParametersViewModel parameters))
-            {
-                return parameters;
-            }
-
-            Either<BaseError, PlexConnectionParametersViewModel> maybeParameters =
-                await Validate(request)
-                    .MapT(
-                        cp => new PlexConnectionParametersViewModel(
-                            new Uri(cp.ActiveConnection.Uri),
-                            cp.PlexServerAuthToken.AuthToken))
-                    .Map(v => v.ToEither<PlexConnectionParametersViewModel>());
-
-            return maybeParameters.Match(
-                p =>
-                {
-                    _memoryCache.Set(request, p, TimeSpan.FromHours(1));
-                    return maybeParameters;
-                },
-                error => error);
-        }
-
-        private Task<Validation<BaseError, ConnectionParameters>> Validate(GetPlexConnectionParameters request) =>
-            PlexMediaSourceMustExist(request)
-                .BindT(MediaSourceMustHaveActiveConnection)
-                .BindT(MediaSourceMustHaveToken);
-
-        private Task<Validation<BaseError, PlexMediaSource>> PlexMediaSourceMustExist(
-            GetPlexConnectionParameters request) =>
-            _mediaSourceRepository.GetPlex(request.PlexMediaSourceId)
-                .Map(
-                    v => v.ToValidation<BaseError>(
-                        $"Plex media source {request.PlexMediaSourceId} does not exist."));
-
-        private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
-            PlexMediaSource plexMediaSource)
-        {
-            Option<PlexConnection> maybeConnection =
-                plexMediaSource.Connections.SingleOrDefault(c => c.IsActive);
-            return maybeConnection.Map(connection => new ConnectionParameters(plexMediaSource, connection))
-                .ToValidation<BaseError>("Plex media source requires an active connection");
-        }
-
-        private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveToken(
-            ConnectionParameters connectionParameters)
-        {
-            Option<PlexServerAuthToken> maybeToken = await
-                _plexSecretStore.GetServerAuthToken(connectionParameters.PlexMediaSource.ClientIdentifier);
-            return maybeToken.Map(token => connectionParameters with { PlexServerAuthToken = token })
-                .ToValidation<BaseError>("Plex media source requires a token");
-        }
-
-        private record ConnectionParameters(PlexMediaSource PlexMediaSource, PlexConnection ActiveConnection)
-        {
-            public PlexServerAuthToken PlexServerAuthToken { get; set; }
-        }
+        _memoryCache = memoryCache;
+        _mediaSourceRepository = mediaSourceRepository;
+        _plexSecretStore = plexSecretStore;
     }
-}
+
+    public async Task<Either<BaseError, PlexConnectionParametersViewModel>> Handle(
+        GetPlexConnectionParameters request,
+        CancellationToken cancellationToken)
+    {
+        if (_memoryCache.TryGetValue(request, out PlexConnectionParametersViewModel parameters))
+        {
+            return parameters;
+        }
+
+        Either<BaseError, PlexConnectionParametersViewModel> maybeParameters =
+            await Validate(request)
+                .MapT(
+                    cp => new PlexConnectionParametersViewModel(
+                        new Uri(cp.ActiveConnection.Uri),
+                        cp.PlexServerAuthToken.AuthToken))
+                .Map(v => v.ToEither<PlexConnectionParametersViewModel>());
+
+        return maybeParameters.Match(
+            p =>
+            {
+                _memoryCache.Set(request, p, TimeSpan.FromHours(1));
+                return maybeParameters;
+            },
+            error => error);
+    }
+
+    private Task<Validation<BaseError, ConnectionParameters>> Validate(GetPlexConnectionParameters request) =>
+        PlexMediaSourceMustExist(request)
+            .BindT(MediaSourceMustHaveActiveConnection)
+            .BindT(MediaSourceMustHaveToken);
+
+    private Task<Validation<BaseError, PlexMediaSource>> PlexMediaSourceMustExist(
+        GetPlexConnectionParameters request) =>
+        _mediaSourceRepository.GetPlex(request.PlexMediaSourceId)
+            .Map(
+                v => v.ToValidation<BaseError>(
+                    $"Plex media source {request.PlexMediaSourceId} does not exist."));
+
+    private Validation<BaseError, ConnectionParameters> MediaSourceMustHaveActiveConnection(
+        PlexMediaSource plexMediaSource)
+    {
+        Option<PlexConnection> maybeConnection =
+            plexMediaSource.Connections.SingleOrDefault(c => c.IsActive);
+        return maybeConnection.Map(connection => new ConnectionParameters(plexMediaSource, connection))
+            .ToValidation<BaseError>("Plex media source requires an active connection");
+    }
+
+    private async Task<Validation<BaseError, ConnectionParameters>> MediaSourceMustHaveToken(
+        ConnectionParameters connectionParameters)
+    {
+        Option<PlexServerAuthToken> maybeToken = await
+            _plexSecretStore.GetServerAuthToken(connectionParameters.PlexMediaSource.ClientIdentifier);
+        return maybeToken.Map(token => connectionParameters with { PlexServerAuthToken = token })
+            .ToValidation<BaseError>("Plex media source requires a token");
+    }
+
+    private record ConnectionParameters(PlexMediaSource PlexMediaSource, PlexConnection ActiveConnection)
+    {
+        public PlexServerAuthToken PlexServerAuthToken { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetPlexLibrariesBySourceId.cs b/ErsatzTV.Application/Plex/Queries/GetPlexLibrariesBySourceId.cs
index 11da4bc88..150cdc294 100644
--- a/ErsatzTV.Application/Plex/Queries/GetPlexLibrariesBySourceId.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetPlexLibrariesBySourceId.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Plex;
 
-namespace ErsatzTV.Application.Plex.Queries
-{
-    public record GetPlexLibrariesBySourceId(int PlexMediaSourceId) : IRequest<List<PlexLibraryViewModel>>;
-}
+public record GetPlexLibrariesBySourceId(int PlexMediaSourceId) : IRequest<List<PlexLibraryViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetPlexLibrariesBySourceIdHandler.cs b/ErsatzTV.Application/Plex/Queries/GetPlexLibrariesBySourceIdHandler.cs
index e73dd612f..9bfc86ea7 100644
--- a/ErsatzTV.Application/Plex/Queries/GetPlexLibrariesBySourceIdHandler.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetPlexLibrariesBySourceIdHandler.cs
@@ -1,27 +1,20 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Plex.Mapper;
 
-namespace ErsatzTV.Application.Plex.Queries
+namespace ErsatzTV.Application.Plex;
+
+public class
+    GetPlexLibrariesBySourceIdHandler : IRequestHandler<GetPlexLibrariesBySourceId,
+        List<PlexLibraryViewModel>>
 {
-    public class
-        GetPlexLibrariesBySourceIdHandler : IRequestHandler<GetPlexLibrariesBySourceId,
-            List<PlexLibraryViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetPlexLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetPlexLibrariesBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<PlexLibraryViewModel>> Handle(
-            GetPlexLibrariesBySourceId request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetPlexLibraries(request.PlexMediaSourceId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<PlexLibraryViewModel>> Handle(
+        GetPlexLibrariesBySourceId request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetPlexLibraries(request.PlexMediaSourceId)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetPlexMediaSourceById.cs b/ErsatzTV.Application/Plex/Queries/GetPlexMediaSourceById.cs
index 5fdc05044..8e89fc273 100644
--- a/ErsatzTV.Application/Plex/Queries/GetPlexMediaSourceById.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetPlexMediaSourceById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Plex;
 
-namespace ErsatzTV.Application.Plex.Queries
-{
-    public record GetPlexMediaSourceById(int PlexMediaSourceId) : IRequest<Option<PlexMediaSourceViewModel>>;
-}
+public record GetPlexMediaSourceById(int PlexMediaSourceId) : IRequest<Option<PlexMediaSourceViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetPlexMediaSourceByIdHandler.cs b/ErsatzTV.Application/Plex/Queries/GetPlexMediaSourceByIdHandler.cs
index 8bd9f9f19..46337c903 100644
--- a/ErsatzTV.Application/Plex/Queries/GetPlexMediaSourceByIdHandler.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetPlexMediaSourceByIdHandler.cs
@@ -1,23 +1,18 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Plex.Mapper;
 
-namespace ErsatzTV.Application.Plex.Queries
+namespace ErsatzTV.Application.Plex;
+
+public class
+    GetPlexMediaSourceByIdHandler : IRequestHandler<GetPlexMediaSourceById, Option<PlexMediaSourceViewModel>>
 {
-    public class
-        GetPlexMediaSourceByIdHandler : IRequestHandler<GetPlexMediaSourceById, Option<PlexMediaSourceViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetPlexMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetPlexMediaSourceByIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<Option<PlexMediaSourceViewModel>> Handle(
-            GetPlexMediaSourceById request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetPlex(request.PlexMediaSourceId).MapT(ProjectToViewModel);
-    }
-}
+    public Task<Option<PlexMediaSourceViewModel>> Handle(
+        GetPlexMediaSourceById request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetPlex(request.PlexMediaSourceId).MapT(ProjectToViewModel);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetPlexPathReplacementsBySourceId.cs b/ErsatzTV.Application/Plex/Queries/GetPlexPathReplacementsBySourceId.cs
index 5246d3d08..b153ef3e7 100644
--- a/ErsatzTV.Application/Plex/Queries/GetPlexPathReplacementsBySourceId.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetPlexPathReplacementsBySourceId.cs
@@ -1,8 +1,4 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Plex;
 
-namespace ErsatzTV.Application.Plex.Queries
-{
-    public record GetPlexPathReplacementsBySourceId
-        (int PlexMediaSourceId) : IRequest<List<PlexPathReplacementViewModel>>;
-}
+public record GetPlexPathReplacementsBySourceId
+    (int PlexMediaSourceId) : IRequest<List<PlexPathReplacementViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Plex/Queries/GetPlexPathReplacementsBySourceIdHandler.cs b/ErsatzTV.Application/Plex/Queries/GetPlexPathReplacementsBySourceIdHandler.cs
index d5aa31cd3..45913a458 100644
--- a/ErsatzTV.Application/Plex/Queries/GetPlexPathReplacementsBySourceIdHandler.cs
+++ b/ErsatzTV.Application/Plex/Queries/GetPlexPathReplacementsBySourceIdHandler.cs
@@ -1,26 +1,19 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core.Interfaces.Repositories;
 using static ErsatzTV.Application.Plex.Mapper;
 
-namespace ErsatzTV.Application.Plex.Queries
+namespace ErsatzTV.Application.Plex;
+
+public class GetPlexPathReplacementsBySourceIdHandler : IRequestHandler<GetPlexPathReplacementsBySourceId,
+    List<PlexPathReplacementViewModel>>
 {
-    public class GetPlexPathReplacementsBySourceIdHandler : IRequestHandler<GetPlexPathReplacementsBySourceId,
-        List<PlexPathReplacementViewModel>>
-    {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
 
-        public GetPlexPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
-            _mediaSourceRepository = mediaSourceRepository;
+    public GetPlexPathReplacementsBySourceIdHandler(IMediaSourceRepository mediaSourceRepository) =>
+        _mediaSourceRepository = mediaSourceRepository;
 
-        public Task<List<PlexPathReplacementViewModel>> Handle(
-            GetPlexPathReplacementsBySourceId request,
-            CancellationToken cancellationToken) =>
-            _mediaSourceRepository.GetPlexPathReplacements(request.PlexMediaSourceId)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<PlexPathReplacementViewModel>> Handle(
+        GetPlexPathReplacementsBySourceId request,
+        CancellationToken cancellationToken) =>
+        _mediaSourceRepository.GetPlexPathReplacements(request.PlexMediaSourceId)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs b/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs
index cfbb0cc67..ecd869fb4 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs
@@ -1,30 +1,26 @@
-using System;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
-{
-    public record AddProgramScheduleItem(
-        int ProgramScheduleId,
-        StartType StartType,
-        TimeSpan? StartTime,
-        PlayoutMode PlayoutMode,
-        ProgramScheduleItemCollectionType CollectionType,
-        int? CollectionId,
-        int? MultiCollectionId,
-        int? SmartCollectionId,
-        int? MediaItemId,
-        PlaybackOrder PlaybackOrder,
-        int? MultipleCount,
-        TimeSpan? PlayoutDuration,
-        TailMode TailMode,
-        string CustomTitle,
-        GuideMode GuideMode,
-        int? PreRollFillerId,
-        int? MidRollFillerId,
-        int? PostRollFillerId,
-        int? TailFillerId,
-        int? FallbackFillerId) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
-}
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record AddProgramScheduleItem(
+    int ProgramScheduleId,
+    StartType StartType,
+    TimeSpan? StartTime,
+    PlayoutMode PlayoutMode,
+    ProgramScheduleItemCollectionType CollectionType,
+    int? CollectionId,
+    int? MultiCollectionId,
+    int? SmartCollectionId,
+    int? MediaItemId,
+    PlaybackOrder PlaybackOrder,
+    int? MultipleCount,
+    TimeSpan? PlayoutDuration,
+    TailMode TailMode,
+    string CustomTitle,
+    GuideMode GuideMode,
+    int? PreRollFillerId,
+    int? MidRollFillerId,
+    int? PostRollFillerId,
+    int? TailFillerId,
+    int? FallbackFillerId) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItemHandler.cs b/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItemHandler.cs
index 7a9866089..d495c23a1 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItemHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItemHandler.cs
@@ -1,66 +1,60 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.ProgramSchedules.Mapper;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class AddProgramScheduleItemHandler : ProgramScheduleItemCommandBase,
+    IRequestHandler<AddProgramScheduleItem, Either<BaseError, ProgramScheduleItemViewModel>>
 {
-    public class AddProgramScheduleItemHandler : ProgramScheduleItemCommandBase,
-        IRequestHandler<AddProgramScheduleItem, Either<BaseError, ProgramScheduleItemViewModel>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public AddProgramScheduleItemHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public AddProgramScheduleItemHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, ProgramScheduleItemViewModel>> Handle(
-            AddProgramScheduleItem request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
-            return await validation.Apply(ps => PersistItem(dbContext, request, ps));
-        }
-
-        private async Task<ProgramScheduleItemViewModel> PersistItem(
-            TvContext dbContext,
-            AddProgramScheduleItem request,
-            ProgramSchedule programSchedule)
-        {
-            int nextIndex = programSchedule.Items.Select(i => i.Index).DefaultIfEmpty(0).Max() + 1;
-
-            ProgramScheduleItem item = BuildItem(programSchedule, nextIndex, request);
-            programSchedule.Items.Add(item);
-
-            await dbContext.SaveChangesAsync();
-
-            // rebuild any playouts that use this schedule
-            foreach (Playout playout in programSchedule.Playouts)
-            {
-                await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
-            }
-
-            return ProjectToViewModel(item);
-        }
-
-        private static Task<Validation<BaseError, ProgramSchedule>> Validate(
-            TvContext dbContext,
-            AddProgramScheduleItem request) =>
-            ProgramScheduleMustExist(dbContext, request.ProgramScheduleId)
-                .BindT(programSchedule => PlayoutModeMustBeValid(request, programSchedule));
+        _dbContextFactory = dbContextFactory;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, ProgramScheduleItemViewModel>> Handle(
+        AddProgramScheduleItem request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, ps => PersistItem(dbContext, request, ps));
+    }
+
+    private async Task<ProgramScheduleItemViewModel> PersistItem(
+        TvContext dbContext,
+        AddProgramScheduleItem request,
+        ProgramSchedule programSchedule)
+    {
+        int nextIndex = programSchedule.Items.Select(i => i.Index).DefaultIfEmpty(0).Max() + 1;
+
+        ProgramScheduleItem item = BuildItem(programSchedule, nextIndex, request);
+        programSchedule.Items.Add(item);
+
+        await dbContext.SaveChangesAsync();
+
+        // rebuild any playouts that use this schedule
+        foreach (Playout playout in programSchedule.Playouts)
+        {
+            await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
+        }
+
+        return ProjectToViewModel(item);
+    }
+
+    private static Task<Validation<BaseError, ProgramSchedule>> Validate(
+        TvContext dbContext,
+        AddProgramScheduleItem request) =>
+        ProgramScheduleMustExist(dbContext, request.ProgramScheduleId)
+            .BindT(programSchedule => PlayoutModeMustBeValid(request, programSchedule));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramSchedule.cs b/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramSchedule.cs
index a659b9c2c..ff210024f 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramSchedule.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramSchedule.cs
@@ -1,13 +1,9 @@
 using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
-{
-    public record CreateProgramSchedule(
-        string Name,
-        bool KeepMultiPartEpisodesTogether,
-        bool TreatCollectionsAsShows,
-        bool ShuffleScheduleItems) : IRequest<Either<BaseError, CreateProgramScheduleResult>>;
-}
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record CreateProgramSchedule(
+    string Name,
+    bool KeepMultiPartEpisodesTogether,
+    bool TreatCollectionsAsShows,
+    bool ShuffleScheduleItems) : IRequest<Either<BaseError, CreateProgramScheduleResult>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs b/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs
index ffbd5d82b..03ec417d2 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleHandler.cs
@@ -1,75 +1,68 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
-using ValidationT_AsyncSync_Extensions = LanguageExt.ValidationT_AsyncSync_Extensions;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class CreateProgramScheduleHandler :
+    IRequestHandler<CreateProgramSchedule, Either<BaseError, CreateProgramScheduleResult>>
 {
-    public class CreateProgramScheduleHandler :
-        IRequestHandler<CreateProgramSchedule, Either<BaseError, CreateProgramScheduleResult>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateProgramScheduleHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, CreateProgramScheduleResult>> Handle(
+        CreateProgramSchedule request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-        public CreateProgramScheduleHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, CreateProgramScheduleResult>> Handle(
-            CreateProgramSchedule request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
-            return await validation.Apply(ps => PersistProgramSchedule(dbContext, ps));
-        }
-
-        private static async Task<CreateProgramScheduleResult> PersistProgramSchedule(
-            TvContext dbContext,
-            ProgramSchedule programSchedule)
-        {
-            await dbContext.ProgramSchedules.AddAsync(programSchedule);
-            await dbContext.SaveChangesAsync();
-            return new CreateProgramScheduleResult(programSchedule.Id);
-        }
-
-        private static Task<Validation<BaseError, ProgramSchedule>> Validate(
-            TvContext dbContext,
-            CreateProgramSchedule request) =>
-            ValidationT_AsyncSync_Extensions.MapT(
-                ValidateName(dbContext, request),
-                name =>
-                {
-                    bool keepMultiPartEpisodesTogether = request.KeepMultiPartEpisodesTogether;
-                    return new ProgramSchedule
-                    {
-                        Name = name,
-                        KeepMultiPartEpisodesTogether = keepMultiPartEpisodesTogether,
-                        TreatCollectionsAsShows = keepMultiPartEpisodesTogether && request.TreatCollectionsAsShows,
-                        ShuffleScheduleItems = request.ShuffleScheduleItems
-                    };
-                });
-
-        private static async Task<Validation<BaseError, string>> ValidateName(
-            TvContext dbContext,
-            CreateProgramSchedule createProgramSchedule)
-        {
-            Validation<BaseError, string> result1 = createProgramSchedule.NotEmpty(c => c.Name)
-                .Bind(_ => createProgramSchedule.NotLongerThan(50)(c => c.Name));
-
-            int duplicateNameCount = await dbContext.ProgramSchedules
-                .CountAsync(ps => ps.Name == createProgramSchedule.Name);
-
-            var result2 = Optional(duplicateNameCount)
-                .Where(count => count == 0)
-                .ToValidation<BaseError>("Schedule name must be unique");
-
-            return (result1, result2).Apply((_, _) => createProgramSchedule.Name);
-        }
+        Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, ps => PersistProgramSchedule(dbContext, ps));
     }
-}
+
+    private static async Task<CreateProgramScheduleResult> PersistProgramSchedule(
+        TvContext dbContext,
+        ProgramSchedule programSchedule)
+    {
+        await dbContext.ProgramSchedules.AddAsync(programSchedule);
+        await dbContext.SaveChangesAsync();
+        return new CreateProgramScheduleResult(programSchedule.Id);
+    }
+
+    private static Task<Validation<BaseError, ProgramSchedule>> Validate(
+        TvContext dbContext,
+        CreateProgramSchedule request) =>
+        ValidationT_AsyncSync_Extensions.MapT(
+            ValidateName(dbContext, request),
+            name =>
+            {
+                bool keepMultiPartEpisodesTogether = request.KeepMultiPartEpisodesTogether;
+                return new ProgramSchedule
+                {
+                    Name = name,
+                    KeepMultiPartEpisodesTogether = keepMultiPartEpisodesTogether,
+                    TreatCollectionsAsShows = keepMultiPartEpisodesTogether && request.TreatCollectionsAsShows,
+                    ShuffleScheduleItems = request.ShuffleScheduleItems
+                };
+            });
+
+    private static async Task<Validation<BaseError, string>> ValidateName(
+        TvContext dbContext,
+        CreateProgramSchedule createProgramSchedule)
+    {
+        Validation<BaseError, string> result1 = createProgramSchedule.NotEmpty(c => c.Name)
+            .Bind(_ => createProgramSchedule.NotLongerThan(50)(c => c.Name));
+
+        int duplicateNameCount = await dbContext.ProgramSchedules
+            .CountAsync(ps => ps.Name == createProgramSchedule.Name);
+
+        var result2 = Optional(duplicateNameCount)
+            .Where(count => count == 0)
+            .ToValidation<BaseError>("Schedule name must be unique");
+
+        return (result1, result2).Apply((_, _) => createProgramSchedule.Name);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleResult.cs b/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleResult.cs
index bb6b51cdf..f22b989f9 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleResult.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/CreateProgramScheduleResult.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.ProgramSchedules.Commands
-{
-    public record CreateProgramScheduleResult(int ProgramScheduleId) : EntityIdResult(ProgramScheduleId);
-}
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record CreateProgramScheduleResult(int ProgramScheduleId) : EntityIdResult(ProgramScheduleId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/DeleteProgramSchedule.cs b/ErsatzTV.Application/ProgramSchedules/Commands/DeleteProgramSchedule.cs
index b7f40e3b3..3e6ce0b57 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/DeleteProgramSchedule.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/DeleteProgramSchedule.cs
@@ -1,8 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
-{
-    public record DeleteProgramSchedule(int ProgramScheduleId) : IRequest<Either<BaseError, LanguageExt.Unit>>;
-}
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record DeleteProgramSchedule(int ProgramScheduleId) : IRequest<Either<BaseError, LanguageExt.Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/DeleteProgramScheduleHandler.cs b/ErsatzTV.Application/ProgramSchedules/Commands/DeleteProgramScheduleHandler.cs
index 3a69ce2e4..46631a508 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/DeleteProgramScheduleHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/DeleteProgramScheduleHandler.cs
@@ -1,43 +1,37 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class DeleteProgramScheduleHandler : IRequestHandler<DeleteProgramSchedule, Either<BaseError, Unit>>
 {
-    public class DeleteProgramScheduleHandler : IRequestHandler<DeleteProgramSchedule, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeleteProgramScheduleHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteProgramSchedule request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public DeleteProgramScheduleHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteProgramSchedule request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, ProgramSchedule> validation = await ProgramScheduleMustExist(dbContext, request);
-            return await validation.Apply(ps => DoDeletion(dbContext, ps));
-        }
-
-        private static Task<Unit> DoDeletion(TvContext dbContext, ProgramSchedule programSchedule)
-        {
-            dbContext.ProgramSchedules.Remove(programSchedule);
-            return dbContext.SaveChangesAsync().ToUnit();
-        }
-
-        private Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
-            TvContext dbContext,
-            DeleteProgramSchedule request) =>
-            dbContext.ProgramSchedules
-                .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.ProgramScheduleId)
-                .Map(o => o.ToValidation<BaseError>($"ProgramSchedule {request.ProgramScheduleId} does not exist."));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, ProgramSchedule> validation = await ProgramScheduleMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, ps => DoDeletion(dbContext, ps));
     }
-}
+
+    private static Task<Unit> DoDeletion(TvContext dbContext, ProgramSchedule programSchedule)
+    {
+        dbContext.ProgramSchedules.Remove(programSchedule);
+        return dbContext.SaveChangesAsync().ToUnit();
+    }
+
+    private Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
+        TvContext dbContext,
+        DeleteProgramSchedule request) =>
+        dbContext.ProgramSchedules
+            .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.ProgramScheduleId)
+            .Map(o => o.ToValidation<BaseError>($"ProgramSchedule {request.ProgramScheduleId} does not exist."));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs b/ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs
index e8c9c6bed..354f32a4f 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/IProgramScheduleItemRequest.cs
@@ -1,27 +1,25 @@
-using System;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public interface IProgramScheduleItemRequest
 {
-    public interface IProgramScheduleItemRequest
-    {
-        TimeSpan? StartTime { get; }
-        ProgramScheduleItemCollectionType CollectionType { get; }
-        int? CollectionId { get; }
-        int? MultiCollectionId { get; }
-        int? SmartCollectionId { get; }
-        int? MediaItemId { get; }
-        PlayoutMode PlayoutMode { get; }
-        PlaybackOrder PlaybackOrder { get; }
-        int? MultipleCount { get; }
-        TimeSpan? PlayoutDuration { get; }
-        TailMode TailMode { get; }
-        string CustomTitle { get; }
-        GuideMode GuideMode { get; }
-        int? PreRollFillerId { get; }
-        int? MidRollFillerId { get; }
-        int? PostRollFillerId { get; }
-        int? TailFillerId { get; }
-        int? FallbackFillerId { get; }
-    }
-}
+    TimeSpan? StartTime { get; }
+    ProgramScheduleItemCollectionType CollectionType { get; }
+    int? CollectionId { get; }
+    int? MultiCollectionId { get; }
+    int? SmartCollectionId { get; }
+    int? MediaItemId { get; }
+    PlayoutMode PlayoutMode { get; }
+    PlaybackOrder PlaybackOrder { get; }
+    int? MultipleCount { get; }
+    TimeSpan? PlayoutDuration { get; }
+    TailMode TailMode { get; }
+    string CustomTitle { get; }
+    GuideMode GuideMode { get; }
+    int? PreRollFillerId { get; }
+    int? MidRollFillerId { get; }
+    int? PostRollFillerId { get; }
+    int? TailFillerId { get; }
+    int? FallbackFillerId { get; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs b/ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs
index 808b7cfbf..ba075ec77 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs
@@ -1,258 +1,251 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public abstract class ProgramScheduleItemCommandBase
 {
-    public abstract class ProgramScheduleItemCommandBase
+    protected static Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
+        TvContext dbContext,
+        int programScheduleId) =>
+        dbContext.ProgramSchedules
+            .Include(ps => ps.Items)
+            .Include(ps => ps.Playouts)
+            .SelectOneAsync(ps => ps.Id, ps => ps.Id == programScheduleId)
+            .Map(o => o.ToValidation<BaseError>("[ProgramScheduleId] does not exist."));
+
+    protected static async Task<Either<BaseError, ProgramSchedule>> FillerConfigurationMustBeValid(
+        TvContext dbContext,
+        IProgramScheduleItemRequest item,
+        ProgramSchedule programSchedule)
     {
-        protected static Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
-            TvContext dbContext,
-            int programScheduleId) =>
-            dbContext.ProgramSchedules
-                .Include(ps => ps.Items)
-                .Include(ps => ps.Playouts)
-                .SelectOneAsync(ps => ps.Id, ps => ps.Id == programScheduleId)
-                .Map(o => o.ToValidation<BaseError>("[ProgramScheduleId] does not exist."));
+        var allFillerIds = Optional(item.PreRollFillerId)
+            .Append(Optional(item.MidRollFillerId))
+            .Append(Optional(item.PostRollFillerId))
+            .ToList();
 
-        protected static async Task<Either<BaseError, ProgramSchedule>> FillerConfigurationMustBeValid(
-            TvContext dbContext,
-            IProgramScheduleItemRequest item,
-            ProgramSchedule programSchedule)
-        {
-            var allFillerIds = Optional(item.PreRollFillerId)
-                .Append(Optional(item.MidRollFillerId))
-                .Append(Optional(item.PostRollFillerId))
-                .ToList();
-
-            List<FillerPreset> allFiller = await dbContext.FillerPresets
-                .Filter(fp => allFillerIds.Contains(fp.Id))
-                .ToListAsync();
+        List<FillerPreset> allFiller = await dbContext.FillerPresets
+            .Filter(fp => allFillerIds.Contains(fp.Id))
+            .ToListAsync();
             
-            if (allFiller.Count(f => f.PadToNearestMinute.HasValue) > 1)
-            {
-                return BaseError.New("Schedule may only contain one filler preset that is configured to pad");
-            }
-
-            if (allFiller.Any(fp => fp.PadToNearestMinute.HasValue) && !item.FallbackFillerId.HasValue)
-            {
-                return BaseError.New("Fallback filler is required when padding");
-            }
-
-            return programSchedule;
-        }
-
-        protected static Validation<BaseError, ProgramSchedule> PlayoutModeMustBeValid(
-            IProgramScheduleItemRequest item,
-            ProgramSchedule programSchedule)
+        if (allFiller.Count(f => f.PadToNearestMinute.HasValue) > 1)
         {
-            if (item.MultiCollectionId.HasValue)
-            {
-                switch (item.PlaybackOrder)
-                {
-                    case PlaybackOrder.Chronological:
-                    case PlaybackOrder.Random:
-                        return BaseError.New($"Invalid playback order for multi collection: '{item.PlaybackOrder}'");
-                    case PlaybackOrder.Shuffle:
-                    case PlaybackOrder.ShuffleInOrder:
-                        break;
-                }
-            }
-
-            switch (item.PlayoutMode)
-            {
-                case PlayoutMode.Flood:
-                case PlayoutMode.One:
-                    break;
-                case PlayoutMode.Multiple:
-                    if (item.MultipleCount.GetValueOrDefault() < 0)
-                    {
-                        return BaseError.New("[MultipleCount] must be greater than or equal to 0 for playout mode 'multiple'");
-                    }
-
-                    break;
-                case PlayoutMode.Duration:
-                    if (item.PlayoutDuration is null)
-                    {
-                        return BaseError.New("[PlayoutDuration] is required for playout mode 'duration'");
-                    }
-
-                    if (item.TailMode == TailMode.Filler && item.TailFillerId == null)
-                    {
-                        return BaseError.New("Tail Filler is required with tail mode Filler");
-                    }
-
-                    if (item.TailFillerId != null && item.TailMode != TailMode.Filler)
-                    {
-                        return BaseError.New("Tail Filler will not be used unless tail mode is set to Filler");
-                    }
-
-                    break;
-                default:
-                    return BaseError.New("[PlayoutMode] is invalid");
-            }
-
-            return programSchedule;
+            return BaseError.New("Schedule may only contain one filler preset that is configured to pad");
         }
 
-        protected Validation<BaseError, ProgramSchedule> CollectionTypeMustBeValid(
-            IProgramScheduleItemRequest item,
-            ProgramSchedule programSchedule)
+        if (allFiller.Any(fp => fp.PadToNearestMinute.HasValue) && !item.FallbackFillerId.HasValue)
         {
-            switch (item.CollectionType)
-            {
-                case ProgramScheduleItemCollectionType.Collection:
-                    if (item.CollectionId is null)
-                    {
-                        return BaseError.New("[Collection] is required for collection type 'Collection'");
-                    }
-
-                    break;
-                case ProgramScheduleItemCollectionType.TelevisionShow:
-                    if (item.MediaItemId is null)
-                    {
-                        return BaseError.New("[MediaItem] is required for collection type 'TelevisionShow'");
-                    }
-
-                    break;
-                case ProgramScheduleItemCollectionType.TelevisionSeason:
-                    if (item.MediaItemId is null)
-                    {
-                        return BaseError.New("[MediaItem] is required for collection type 'TelevisionSeason'");
-                    }
-
-                    break;
-                case ProgramScheduleItemCollectionType.Artist:
-                    if (item.MediaItemId is null)
-                    {
-                        return BaseError.New("[MediaItem] is required for collection type 'Artist'");
-                    }
-
-                    break;
-                case ProgramScheduleItemCollectionType.MultiCollection:
-                    if (item.MultiCollectionId is null)
-                    {
-                        return BaseError.New("[MultiCollection] is required for collection type 'MultiCollection'");
-                    }
-
-                    break;
-                case ProgramScheduleItemCollectionType.SmartCollection:
-                    if (item.SmartCollectionId is null)
-                    {
-                        return BaseError.New("[SmartCollection] is required for collection type 'SmartCollection'");
-                    }
-
-                    break;
-                default:
-                    return BaseError.New("[CollectionType] is invalid");
-            }
-
-            return programSchedule;
+            return BaseError.New("Fallback filler is required when padding");
         }
 
-        protected ProgramScheduleItem BuildItem(
-            ProgramSchedule programSchedule,
-            int index,
-            IProgramScheduleItemRequest item) =>
-            item.PlayoutMode switch
-            {
-                PlayoutMode.Flood => new ProgramScheduleItemFlood
-                {
-                    ProgramScheduleId = programSchedule.Id,
-                    Index = index,
-                    StartTime = FixStartTime(item.StartTime),
-                    CollectionType = item.CollectionType,
-                    CollectionId = item.CollectionId,
-                    MultiCollectionId = item.MultiCollectionId,
-                    SmartCollectionId = item.SmartCollectionId,
-                    MediaItemId = item.MediaItemId,
-                    PlaybackOrder = item.PlaybackOrder,
-                    CustomTitle = item.CustomTitle,
-                    GuideMode = item.GuideMode,
-                    PreRollFillerId = item.PreRollFillerId,
-                    MidRollFillerId = item.MidRollFillerId,
-                    PostRollFillerId = item.PostRollFillerId,
-                    TailFillerId = item.TailFillerId,
-                    FallbackFillerId = item.FallbackFillerId
-                },
-                PlayoutMode.One => new ProgramScheduleItemOne
-                {
-                    ProgramScheduleId = programSchedule.Id,
-                    Index = index,
-                    StartTime = FixStartTime(item.StartTime),
-                    CollectionType = item.CollectionType,
-                    CollectionId = item.CollectionId,
-                    MultiCollectionId = item.MultiCollectionId,
-                    SmartCollectionId = item.SmartCollectionId,
-                    MediaItemId = item.MediaItemId,
-                    PlaybackOrder = item.PlaybackOrder,
-                    CustomTitle = item.CustomTitle,
-                    GuideMode = item.GuideMode,
-                    PreRollFillerId = item.PreRollFillerId,
-                    MidRollFillerId = item.MidRollFillerId,
-                    PostRollFillerId = item.PostRollFillerId,
-                    TailFillerId = item.TailFillerId,
-                    FallbackFillerId = item.FallbackFillerId
-                },
-                PlayoutMode.Multiple => new ProgramScheduleItemMultiple
-                {
-                    ProgramScheduleId = programSchedule.Id,
-                    Index = index,
-                    StartTime = FixStartTime(item.StartTime),
-                    CollectionType = item.CollectionType,
-                    CollectionId = item.CollectionId,
-                    MultiCollectionId = item.MultiCollectionId,
-                    SmartCollectionId = item.SmartCollectionId,
-                    MediaItemId = item.MediaItemId,
-                    PlaybackOrder = item.PlaybackOrder,
-                    Count = item.MultipleCount.GetValueOrDefault(),
-                    CustomTitle = item.CustomTitle,
-                    GuideMode = item.GuideMode,
-                    PreRollFillerId = item.PreRollFillerId,
-                    MidRollFillerId = item.MidRollFillerId,
-                    PostRollFillerId = item.PostRollFillerId,
-                    TailFillerId = item.TailFillerId,
-                    FallbackFillerId = item.FallbackFillerId
-                },
-                PlayoutMode.Duration => new ProgramScheduleItemDuration
-                {
-                    ProgramScheduleId = programSchedule.Id,
-                    Index = index,
-                    StartTime = FixStartTime(item.StartTime),
-                    CollectionType = item.CollectionType,
-                    CollectionId = item.CollectionId,
-                    MultiCollectionId = item.MultiCollectionId,
-                    SmartCollectionId = item.SmartCollectionId,
-                    MediaItemId = item.MediaItemId,
-                    PlaybackOrder = item.PlaybackOrder,
-                    PlayoutDuration = FixDuration(item.PlayoutDuration.GetValueOrDefault()),
-                    TailMode = item.TailMode,
-                    CustomTitle = item.CustomTitle,
-                    GuideMode = item.GuideMode,
-                    PreRollFillerId = item.PreRollFillerId,
-                    MidRollFillerId = item.MidRollFillerId,
-                    PostRollFillerId = item.PostRollFillerId,
-                    TailFillerId = item.TailFillerId,
-                    FallbackFillerId = item.FallbackFillerId
-                },
-                _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
-            };
-
-        private static TimeSpan FixDuration(TimeSpan duration) =>
-            duration >= TimeSpan.FromDays(1) ? duration.Subtract(TimeSpan.FromDays(1)) : duration;
-
-        private static TimeSpan? FixStartTime(TimeSpan? startTime) =>
-            startTime.HasValue && startTime.Value >= TimeSpan.FromDays(1)
-                ? startTime.Value.Subtract(TimeSpan.FromDays(1))
-                : startTime;
+        return programSchedule;
     }
-}
+
+    protected static Validation<BaseError, ProgramSchedule> PlayoutModeMustBeValid(
+        IProgramScheduleItemRequest item,
+        ProgramSchedule programSchedule)
+    {
+        if (item.MultiCollectionId.HasValue)
+        {
+            switch (item.PlaybackOrder)
+            {
+                case PlaybackOrder.Chronological:
+                case PlaybackOrder.Random:
+                    return BaseError.New($"Invalid playback order for multi collection: '{item.PlaybackOrder}'");
+                case PlaybackOrder.Shuffle:
+                case PlaybackOrder.ShuffleInOrder:
+                    break;
+            }
+        }
+
+        switch (item.PlayoutMode)
+        {
+            case PlayoutMode.Flood:
+            case PlayoutMode.One:
+                break;
+            case PlayoutMode.Multiple:
+                if (item.MultipleCount.GetValueOrDefault() < 0)
+                {
+                    return BaseError.New("[MultipleCount] must be greater than or equal to 0 for playout mode 'multiple'");
+                }
+
+                break;
+            case PlayoutMode.Duration:
+                if (item.PlayoutDuration is null)
+                {
+                    return BaseError.New("[PlayoutDuration] is required for playout mode 'duration'");
+                }
+
+                if (item.TailMode == TailMode.Filler && item.TailFillerId == null)
+                {
+                    return BaseError.New("Tail Filler is required with tail mode Filler");
+                }
+
+                if (item.TailFillerId != null && item.TailMode != TailMode.Filler)
+                {
+                    return BaseError.New("Tail Filler will not be used unless tail mode is set to Filler");
+                }
+
+                break;
+            default:
+                return BaseError.New("[PlayoutMode] is invalid");
+        }
+
+        return programSchedule;
+    }
+
+    protected Validation<BaseError, ProgramSchedule> CollectionTypeMustBeValid(
+        IProgramScheduleItemRequest item,
+        ProgramSchedule programSchedule)
+    {
+        switch (item.CollectionType)
+        {
+            case ProgramScheduleItemCollectionType.Collection:
+                if (item.CollectionId is null)
+                {
+                    return BaseError.New("[Collection] is required for collection type 'Collection'");
+                }
+
+                break;
+            case ProgramScheduleItemCollectionType.TelevisionShow:
+                if (item.MediaItemId is null)
+                {
+                    return BaseError.New("[MediaItem] is required for collection type 'TelevisionShow'");
+                }
+
+                break;
+            case ProgramScheduleItemCollectionType.TelevisionSeason:
+                if (item.MediaItemId is null)
+                {
+                    return BaseError.New("[MediaItem] is required for collection type 'TelevisionSeason'");
+                }
+
+                break;
+            case ProgramScheduleItemCollectionType.Artist:
+                if (item.MediaItemId is null)
+                {
+                    return BaseError.New("[MediaItem] is required for collection type 'Artist'");
+                }
+
+                break;
+            case ProgramScheduleItemCollectionType.MultiCollection:
+                if (item.MultiCollectionId is null)
+                {
+                    return BaseError.New("[MultiCollection] is required for collection type 'MultiCollection'");
+                }
+
+                break;
+            case ProgramScheduleItemCollectionType.SmartCollection:
+                if (item.SmartCollectionId is null)
+                {
+                    return BaseError.New("[SmartCollection] is required for collection type 'SmartCollection'");
+                }
+
+                break;
+            default:
+                return BaseError.New("[CollectionType] is invalid");
+        }
+
+        return programSchedule;
+    }
+
+    protected ProgramScheduleItem BuildItem(
+        ProgramSchedule programSchedule,
+        int index,
+        IProgramScheduleItemRequest item) =>
+        item.PlayoutMode switch
+        {
+            PlayoutMode.Flood => new ProgramScheduleItemFlood
+            {
+                ProgramScheduleId = programSchedule.Id,
+                Index = index,
+                StartTime = FixStartTime(item.StartTime),
+                CollectionType = item.CollectionType,
+                CollectionId = item.CollectionId,
+                MultiCollectionId = item.MultiCollectionId,
+                SmartCollectionId = item.SmartCollectionId,
+                MediaItemId = item.MediaItemId,
+                PlaybackOrder = item.PlaybackOrder,
+                CustomTitle = item.CustomTitle,
+                GuideMode = item.GuideMode,
+                PreRollFillerId = item.PreRollFillerId,
+                MidRollFillerId = item.MidRollFillerId,
+                PostRollFillerId = item.PostRollFillerId,
+                TailFillerId = item.TailFillerId,
+                FallbackFillerId = item.FallbackFillerId
+            },
+            PlayoutMode.One => new ProgramScheduleItemOne
+            {
+                ProgramScheduleId = programSchedule.Id,
+                Index = index,
+                StartTime = FixStartTime(item.StartTime),
+                CollectionType = item.CollectionType,
+                CollectionId = item.CollectionId,
+                MultiCollectionId = item.MultiCollectionId,
+                SmartCollectionId = item.SmartCollectionId,
+                MediaItemId = item.MediaItemId,
+                PlaybackOrder = item.PlaybackOrder,
+                CustomTitle = item.CustomTitle,
+                GuideMode = item.GuideMode,
+                PreRollFillerId = item.PreRollFillerId,
+                MidRollFillerId = item.MidRollFillerId,
+                PostRollFillerId = item.PostRollFillerId,
+                TailFillerId = item.TailFillerId,
+                FallbackFillerId = item.FallbackFillerId
+            },
+            PlayoutMode.Multiple => new ProgramScheduleItemMultiple
+            {
+                ProgramScheduleId = programSchedule.Id,
+                Index = index,
+                StartTime = FixStartTime(item.StartTime),
+                CollectionType = item.CollectionType,
+                CollectionId = item.CollectionId,
+                MultiCollectionId = item.MultiCollectionId,
+                SmartCollectionId = item.SmartCollectionId,
+                MediaItemId = item.MediaItemId,
+                PlaybackOrder = item.PlaybackOrder,
+                Count = item.MultipleCount.GetValueOrDefault(),
+                CustomTitle = item.CustomTitle,
+                GuideMode = item.GuideMode,
+                PreRollFillerId = item.PreRollFillerId,
+                MidRollFillerId = item.MidRollFillerId,
+                PostRollFillerId = item.PostRollFillerId,
+                TailFillerId = item.TailFillerId,
+                FallbackFillerId = item.FallbackFillerId
+            },
+            PlayoutMode.Duration => new ProgramScheduleItemDuration
+            {
+                ProgramScheduleId = programSchedule.Id,
+                Index = index,
+                StartTime = FixStartTime(item.StartTime),
+                CollectionType = item.CollectionType,
+                CollectionId = item.CollectionId,
+                MultiCollectionId = item.MultiCollectionId,
+                SmartCollectionId = item.SmartCollectionId,
+                MediaItemId = item.MediaItemId,
+                PlaybackOrder = item.PlaybackOrder,
+                PlayoutDuration = FixDuration(item.PlayoutDuration.GetValueOrDefault()),
+                TailMode = item.TailMode,
+                CustomTitle = item.CustomTitle,
+                GuideMode = item.GuideMode,
+                PreRollFillerId = item.PreRollFillerId,
+                MidRollFillerId = item.MidRollFillerId,
+                PostRollFillerId = item.PostRollFillerId,
+                TailFillerId = item.TailFillerId,
+                FallbackFillerId = item.FallbackFillerId
+            },
+            _ => throw new NotSupportedException($"Unsupported playout mode {item.PlayoutMode}")
+        };
+
+    private static TimeSpan FixDuration(TimeSpan duration) =>
+        duration >= TimeSpan.FromDays(1) ? duration.Subtract(TimeSpan.FromDays(1)) : duration;
+
+    private static TimeSpan? FixStartTime(TimeSpan? startTime) =>
+        startTime.HasValue && startTime.Value >= TimeSpan.FromDays(1)
+            ? startTime.Value.Subtract(TimeSpan.FromDays(1))
+            : startTime;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs b/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs
index 5afe4097f..7b6d11f64 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItems.cs
@@ -1,35 +1,30 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
-{
-    public record ReplaceProgramScheduleItem(
-        int Index,
-        StartType StartType,
-        TimeSpan? StartTime,
-        PlayoutMode PlayoutMode,
-        ProgramScheduleItemCollectionType CollectionType,
-        int? CollectionId,
-        int? MultiCollectionId,
-        int? SmartCollectionId,
-        int? MediaItemId,
-        PlaybackOrder PlaybackOrder,
-        int? MultipleCount,
-        TimeSpan? PlayoutDuration,
-        TailMode TailMode,
-        string CustomTitle,
-        GuideMode GuideMode,
-        int? PreRollFillerId,
-        int? MidRollFillerId,
-        int? PostRollFillerId,
-        int? TailFillerId,
-        int? FallbackFillerId) : IProgramScheduleItemRequest;
+namespace ErsatzTV.Application.ProgramSchedules;
 
-    public record ReplaceProgramScheduleItems
-        (int ProgramScheduleId, List<ReplaceProgramScheduleItem> Items) : IRequest<
-            Either<BaseError, IEnumerable<ProgramScheduleItemViewModel>>>;
-}
+public record ReplaceProgramScheduleItem(
+    int Index,
+    StartType StartType,
+    TimeSpan? StartTime,
+    PlayoutMode PlayoutMode,
+    ProgramScheduleItemCollectionType CollectionType,
+    int? CollectionId,
+    int? MultiCollectionId,
+    int? SmartCollectionId,
+    int? MediaItemId,
+    PlaybackOrder PlaybackOrder,
+    int? MultipleCount,
+    TimeSpan? PlayoutDuration,
+    TailMode TailMode,
+    string CustomTitle,
+    GuideMode GuideMode,
+    int? PreRollFillerId,
+    int? MidRollFillerId,
+    int? PostRollFillerId,
+    int? TailFillerId,
+    int? FallbackFillerId) : IProgramScheduleItemRequest;
+
+public record ReplaceProgramScheduleItems
+    (int ProgramScheduleId, List<ReplaceProgramScheduleItem> Items) : IRequest<
+        Either<BaseError, IEnumerable<ProgramScheduleItemViewModel>>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItemsHandler.cs b/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItemsHandler.cs
index b0ddbc2a0..ac4cb17dd 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItemsHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItemsHandler.cs
@@ -1,139 +1,131 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.ProgramSchedules.Mapper;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class ReplaceProgramScheduleItemsHandler : ProgramScheduleItemCommandBase,
+    IRequestHandler<ReplaceProgramScheduleItems, Either<BaseError, IEnumerable<ProgramScheduleItemViewModel>>>
 {
-    public class ReplaceProgramScheduleItemsHandler : ProgramScheduleItemCommandBase,
-        IRequestHandler<ReplaceProgramScheduleItems, Either<BaseError, IEnumerable<ProgramScheduleItemViewModel>>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+
+    public ReplaceProgramScheduleItemsHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-
-        public ReplaceProgramScheduleItemsHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, IEnumerable<ProgramScheduleItemViewModel>>> Handle(
-            ReplaceProgramScheduleItems request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
-            return await validation.Apply(ps => PersistItems(dbContext, request, ps));
-        }
-
-        private async Task<IEnumerable<ProgramScheduleItemViewModel>> PersistItems(
-            TvContext dbContext,
-            ReplaceProgramScheduleItems request,
-            ProgramSchedule programSchedule)
-        {
-            dbContext.RemoveRange(programSchedule.Items);
-            programSchedule.Items = request.Items.Map(i => BuildItem(programSchedule, i.Index, i)).ToList();
-
-            await dbContext.SaveChangesAsync();
-
-            // rebuild any playouts that use this schedule
-            foreach (Playout playout in programSchedule.Playouts)
-            {
-                await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
-            }
-
-            return programSchedule.Items.Map(ProjectToViewModel);
-        }
-
-        private Task<Validation<BaseError, ProgramSchedule>> Validate(
-            TvContext dbContext,
-            ReplaceProgramScheduleItems request) =>
-            ProgramScheduleMustExist(dbContext, request.ProgramScheduleId)
-                .BindT(programSchedule => PlayoutModesMustBeValid(request, programSchedule))
-                .BindT(programSchedule => CollectionTypesMustBeValid(request, programSchedule))
-                .BindT(programSchedule => PlaybackOrdersMustBeValid(request, programSchedule))
-                .BindT(programSchedule => FillerConfigurationsMustBeValid(dbContext, request, programSchedule));
-
-        private static Validation<BaseError, ProgramSchedule> PlayoutModesMustBeValid(
-            ReplaceProgramScheduleItems request,
-            ProgramSchedule programSchedule) =>
-            request.Items.Map(item => PlayoutModeMustBeValid(item, programSchedule)).Sequence()
-                .Map(_ => programSchedule);
-
-        private Validation<BaseError, ProgramSchedule> CollectionTypesMustBeValid(
-            ReplaceProgramScheduleItems request,
-            ProgramSchedule programSchedule) =>
-            request.Items.Map(item => CollectionTypeMustBeValid(item, programSchedule)).Sequence()
-                .Map(_ => programSchedule);
-
-        private static async Task<Validation<BaseError, ProgramSchedule>> FillerConfigurationsMustBeValid(
-            TvContext dbContext,
-            ReplaceProgramScheduleItems request,
-            ProgramSchedule programSchedule)
-        {
-            foreach (ReplaceProgramScheduleItem item in request.Items)
-            {
-                Either<BaseError, ProgramSchedule> result = await FillerConfigurationMustBeValid(
-                    dbContext,
-                    item,
-                    programSchedule);
-                if (result.IsLeft)
-                {
-                    return result.ToValidation();
-                }
-            }
-
-            return programSchedule;
-        }
-
-        private static Validation<BaseError, ProgramSchedule> PlaybackOrdersMustBeValid(
-            ReplaceProgramScheduleItems request,
-            ProgramSchedule programSchedule)
-        {
-            var keyOrders = new Dictionary<CollectionKey, System.Collections.Generic.HashSet<PlaybackOrder>>();
-            foreach (ReplaceProgramScheduleItem item in request.Items)
-            {
-                var key = new CollectionKey(
-                    item.CollectionType,
-                    item.CollectionId,
-                    item.MediaItemId,
-                    item.MultiCollectionId,
-                    item.SmartCollectionId);
-
-                if (keyOrders.TryGetValue(key, out System.Collections.Generic.HashSet<PlaybackOrder> playbackOrders))
-                {
-                    playbackOrders.Add(item.PlaybackOrder);
-                    keyOrders[key] = playbackOrders;
-                }
-                else
-                {
-                    keyOrders.Add(key, new System.Collections.Generic.HashSet<PlaybackOrder> { item.PlaybackOrder });
-                }
-            }
-
-            return Optional(keyOrders.Values.Count(set => set.Count != 1))
-                .Filter(count => count == 0)
-                .Map(_ => programSchedule)
-                .ToValidation<BaseError>("A collection must not use multiple playback orders");
-        }
-
-        private record CollectionKey(
-            ProgramScheduleItemCollectionType CollectionType,
-            int? CollectionId,
-            int? MediaItemId,
-            int? MultiCollectionId,
-            int? SmartCollectionId);
+        _dbContextFactory = dbContextFactory;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, IEnumerable<ProgramScheduleItemViewModel>>> Handle(
+        ReplaceProgramScheduleItems request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, ps => PersistItems(dbContext, request, ps));
+    }
+
+    private async Task<IEnumerable<ProgramScheduleItemViewModel>> PersistItems(
+        TvContext dbContext,
+        ReplaceProgramScheduleItems request,
+        ProgramSchedule programSchedule)
+    {
+        dbContext.RemoveRange(programSchedule.Items);
+        programSchedule.Items = request.Items.Map(i => BuildItem(programSchedule, i.Index, i)).ToList();
+
+        await dbContext.SaveChangesAsync();
+
+        // rebuild any playouts that use this schedule
+        foreach (Playout playout in programSchedule.Playouts)
+        {
+            await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
+        }
+
+        return programSchedule.Items.Map(ProjectToViewModel);
+    }
+
+    private Task<Validation<BaseError, ProgramSchedule>> Validate(
+        TvContext dbContext,
+        ReplaceProgramScheduleItems request) =>
+        ProgramScheduleMustExist(dbContext, request.ProgramScheduleId)
+            .BindT(programSchedule => PlayoutModesMustBeValid(request, programSchedule))
+            .BindT(programSchedule => CollectionTypesMustBeValid(request, programSchedule))
+            .BindT(programSchedule => PlaybackOrdersMustBeValid(request, programSchedule))
+            .BindT(programSchedule => FillerConfigurationsMustBeValid(dbContext, request, programSchedule));
+
+    private static Validation<BaseError, ProgramSchedule> PlayoutModesMustBeValid(
+        ReplaceProgramScheduleItems request,
+        ProgramSchedule programSchedule) =>
+        request.Items.Map(item => PlayoutModeMustBeValid(item, programSchedule)).Sequence()
+            .Map(_ => programSchedule);
+
+    private Validation<BaseError, ProgramSchedule> CollectionTypesMustBeValid(
+        ReplaceProgramScheduleItems request,
+        ProgramSchedule programSchedule) =>
+        request.Items.Map(item => CollectionTypeMustBeValid(item, programSchedule)).Sequence()
+            .Map(_ => programSchedule);
+
+    private static async Task<Validation<BaseError, ProgramSchedule>> FillerConfigurationsMustBeValid(
+        TvContext dbContext,
+        ReplaceProgramScheduleItems request,
+        ProgramSchedule programSchedule)
+    {
+        foreach (ReplaceProgramScheduleItem item in request.Items)
+        {
+            Either<BaseError, ProgramSchedule> result = await FillerConfigurationMustBeValid(
+                dbContext,
+                item,
+                programSchedule);
+            if (result.IsLeft)
+            {
+                return result.ToValidation();
+            }
+        }
+
+        return programSchedule;
+    }
+
+    private static Validation<BaseError, ProgramSchedule> PlaybackOrdersMustBeValid(
+        ReplaceProgramScheduleItems request,
+        ProgramSchedule programSchedule)
+    {
+        var keyOrders = new Dictionary<CollectionKey, System.Collections.Generic.HashSet<PlaybackOrder>>();
+        foreach (ReplaceProgramScheduleItem item in request.Items)
+        {
+            var key = new CollectionKey(
+                item.CollectionType,
+                item.CollectionId,
+                item.MediaItemId,
+                item.MultiCollectionId,
+                item.SmartCollectionId);
+
+            if (keyOrders.TryGetValue(key, out System.Collections.Generic.HashSet<PlaybackOrder> playbackOrders))
+            {
+                playbackOrders.Add(item.PlaybackOrder);
+                keyOrders[key] = playbackOrders;
+            }
+            else
+            {
+                keyOrders.Add(key, new System.Collections.Generic.HashSet<PlaybackOrder> { item.PlaybackOrder });
+            }
+        }
+
+        return Optional(keyOrders.Values.Count(set => set.Count != 1))
+            .Filter(count => count == 0)
+            .Map(_ => programSchedule)
+            .ToValidation<BaseError>("A collection must not use multiple playback orders");
+    }
+
+    private record CollectionKey(
+        ProgramScheduleItemCollectionType CollectionType,
+        int? CollectionId,
+        int? MediaItemId,
+        int? MultiCollectionId,
+        int? SmartCollectionId);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramSchedule.cs b/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramSchedule.cs
index 6f3881af5..c2c8a1143 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramSchedule.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramSchedule.cs
@@ -1,15 +1,11 @@
 using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
-{
-    public record UpdateProgramSchedule
-    (
-        int ProgramScheduleId,
-        string Name,
-        bool KeepMultiPartEpisodesTogether,
-        bool TreatCollectionsAsShows,
-        bool ShuffleScheduleItems) : IRequest<Either<BaseError, UpdateProgramScheduleResult>>;
-}
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record UpdateProgramSchedule
+(
+    int ProgramScheduleId,
+    string Name,
+    bool KeepMultiPartEpisodesTogether,
+    bool TreatCollectionsAsShows,
+    bool ShuffleScheduleItems) : IRequest<Either<BaseError, UpdateProgramScheduleResult>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleHandler.cs b/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleHandler.cs
index 4beb9ff87..ded2771ac 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleHandler.cs
@@ -1,92 +1,86 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Playouts.Commands;
+using System.Threading.Channels;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.ProgramSchedules.Commands
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class UpdateProgramScheduleHandler :
+    IRequestHandler<UpdateProgramSchedule, Either<BaseError, UpdateProgramScheduleResult>>
 {
-    public class UpdateProgramScheduleHandler :
-        IRequestHandler<UpdateProgramSchedule, Either<BaseError, UpdateProgramScheduleResult>>
+    private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdateProgramScheduleHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        ChannelWriter<IBackgroundServiceRequest> channel)
     {
-        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdateProgramScheduleHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            ChannelWriter<IBackgroundServiceRequest> channel)
-        {
-            _dbContextFactory = dbContextFactory;
-            _channel = channel;
-        }
-
-        public async Task<Either<BaseError, UpdateProgramScheduleResult>> Handle(
-            UpdateProgramSchedule request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-            Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
-            return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
-        }
-
-        private async Task<UpdateProgramScheduleResult> ApplyUpdateRequest(
-            TvContext dbContext,
-            ProgramSchedule programSchedule,
-            UpdateProgramSchedule request)
-        {
-            // we need to rebuild playouts if the playback order or keep multi-episodes has been modified
-            bool needToRebuildPlayout =
-                programSchedule.KeepMultiPartEpisodesTogether != request.KeepMultiPartEpisodesTogether ||
-                programSchedule.TreatCollectionsAsShows != request.TreatCollectionsAsShows ||
-                programSchedule.ShuffleScheduleItems != request.ShuffleScheduleItems;
-
-            programSchedule.Name = request.Name;
-            programSchedule.KeepMultiPartEpisodesTogether = request.KeepMultiPartEpisodesTogether;
-            programSchedule.TreatCollectionsAsShows = programSchedule.KeepMultiPartEpisodesTogether &&
-                                                      request.TreatCollectionsAsShows;
-            programSchedule.ShuffleScheduleItems = request.ShuffleScheduleItems;
-
-            await dbContext.SaveChangesAsync();
-
-            if (needToRebuildPlayout)
-            {
-                List<int> playoutIds = await dbContext.Playouts
-                    .Filter(p => p.ProgramScheduleId == programSchedule.Id)
-                    .Map(p => p.Id)
-                    .ToListAsync();
-
-                foreach (int playoutId in playoutIds)
-                {
-                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
-                }
-            }
-
-            return new UpdateProgramScheduleResult(programSchedule.Id);
-        }
-
-        private static async Task<Validation<BaseError, ProgramSchedule>> Validate(
-            TvContext dbContext,
-            UpdateProgramSchedule request) =>
-            (await ProgramScheduleMustExist(dbContext, request), ValidateName(request))
-            .Apply((programSchedule, _) => programSchedule);
-
-        private static Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
-            TvContext dbContext,
-            UpdateProgramSchedule request) =>
-            dbContext.ProgramSchedules
-                .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.ProgramScheduleId)
-                .Map(o => o.ToValidation<BaseError>("ProgramSchedule does not exist"));
-
-        private static Validation<BaseError, string> ValidateName(UpdateProgramSchedule request) =>
-            request.NotEmpty(c => c.Name)
-                .Bind(_ => request.NotLongerThan(50)(c => c.Name));
+        _dbContextFactory = dbContextFactory;
+        _channel = channel;
     }
-}
+
+    public async Task<Either<BaseError, UpdateProgramScheduleResult>> Handle(
+        UpdateProgramSchedule request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        Validation<BaseError, ProgramSchedule> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, ps => ApplyUpdateRequest(dbContext, ps, request));
+    }
+
+    private async Task<UpdateProgramScheduleResult> ApplyUpdateRequest(
+        TvContext dbContext,
+        ProgramSchedule programSchedule,
+        UpdateProgramSchedule request)
+    {
+        // we need to rebuild playouts if the playback order or keep multi-episodes has been modified
+        bool needToRebuildPlayout =
+            programSchedule.KeepMultiPartEpisodesTogether != request.KeepMultiPartEpisodesTogether ||
+            programSchedule.TreatCollectionsAsShows != request.TreatCollectionsAsShows ||
+            programSchedule.ShuffleScheduleItems != request.ShuffleScheduleItems;
+
+        programSchedule.Name = request.Name;
+        programSchedule.KeepMultiPartEpisodesTogether = request.KeepMultiPartEpisodesTogether;
+        programSchedule.TreatCollectionsAsShows = programSchedule.KeepMultiPartEpisodesTogether &&
+                                                  request.TreatCollectionsAsShows;
+        programSchedule.ShuffleScheduleItems = request.ShuffleScheduleItems;
+
+        await dbContext.SaveChangesAsync();
+
+        if (needToRebuildPlayout)
+        {
+            List<int> playoutIds = await dbContext.Playouts
+                .Filter(p => p.ProgramScheduleId == programSchedule.Id)
+                .Map(p => p.Id)
+                .ToListAsync();
+
+            foreach (int playoutId in playoutIds)
+            {
+                await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+            }
+        }
+
+        return new UpdateProgramScheduleResult(programSchedule.Id);
+    }
+
+    private static async Task<Validation<BaseError, ProgramSchedule>> Validate(
+        TvContext dbContext,
+        UpdateProgramSchedule request) =>
+        (await ProgramScheduleMustExist(dbContext, request), ValidateName(request))
+        .Apply((programSchedule, _) => programSchedule);
+
+    private static Task<Validation<BaseError, ProgramSchedule>> ProgramScheduleMustExist(
+        TvContext dbContext,
+        UpdateProgramSchedule request) =>
+        dbContext.ProgramSchedules
+            .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.ProgramScheduleId)
+            .Map(o => o.ToValidation<BaseError>("ProgramSchedule does not exist"));
+
+    private static Validation<BaseError, string> ValidateName(UpdateProgramSchedule request) =>
+        request.NotEmpty(c => c.Name)
+            .Bind(_ => request.NotLongerThan(50)(c => c.Name));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleResult.cs b/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleResult.cs
index 4e15e5d07..f79a12350 100644
--- a/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleResult.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/UpdateProgramScheduleResult.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.ProgramSchedules.Commands
-{
-    public record UpdateProgramScheduleResult(int ProgramScheduleId) : EntityIdResult(ProgramScheduleId);
-}
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record UpdateProgramScheduleResult(int ProgramScheduleId) : EntityIdResult(ProgramScheduleId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Mapper.cs b/ErsatzTV.Application/ProgramSchedules/Mapper.cs
index ed8e0e311..089315dd1 100644
--- a/ErsatzTV.Application/ProgramSchedules/Mapper.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Mapper.cs
@@ -1,190 +1,188 @@
-using System;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.ProgramSchedules
+namespace ErsatzTV.Application.ProgramSchedules;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static ProgramScheduleViewModel ProjectToViewModel(ProgramSchedule programSchedule) =>
-            new(
-                programSchedule.Id,
-                programSchedule.Name,
-                programSchedule.KeepMultiPartEpisodesTogether,
-                programSchedule.TreatCollectionsAsShows,
-                programSchedule.ShuffleScheduleItems);
+    internal static ProgramScheduleViewModel ProjectToViewModel(ProgramSchedule programSchedule) =>
+        new(
+            programSchedule.Id,
+            programSchedule.Name,
+            programSchedule.KeepMultiPartEpisodesTogether,
+            programSchedule.TreatCollectionsAsShows,
+            programSchedule.ShuffleScheduleItems);
 
-        internal static ProgramScheduleItemViewModel ProjectToViewModel(ProgramScheduleItem programScheduleItem) =>
-            programScheduleItem switch
-            {
-                ProgramScheduleItemDuration duration =>
-                    new ProgramScheduleItemDurationViewModel(
-                        duration.Id,
-                        duration.Index,
-                        duration.StartType,
-                        duration.StartTime,
-                        duration.CollectionType,
-                        duration.Collection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(duration.Collection)
-                            : null,
-                        duration.MultiCollection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(duration.MultiCollection)
-                            : null,
-                        duration.SmartCollection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(duration.SmartCollection)
-                            : null,
-                        duration.MediaItem switch
-                        {
-                            Show show => MediaItems.Mapper.ProjectToViewModel(show),
-                            Season season => MediaItems.Mapper.ProjectToViewModel(season),
-                            Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
-                            _ => null
-                        },
-                        duration.PlaybackOrder,
-                        duration.PlayoutDuration,
-                        duration.TailMode,
-                        duration.CustomTitle,
-                        duration.GuideMode,
-                        duration.PreRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(duration.PreRollFiller)
-                            : null,
-                        duration.MidRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(duration.MidRollFiller)
-                            : null,
-                        duration.PostRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(duration.PostRollFiller)
-                            : null,
-                        duration.TailFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(duration.TailFiller)
-                            : null,
-                        duration.FallbackFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(duration.FallbackFiller)
-                            : null),
-                ProgramScheduleItemFlood flood =>
-                    new ProgramScheduleItemFloodViewModel(
-                        flood.Id,
-                        flood.Index,
-                        flood.StartType,
-                        flood.StartTime,
-                        flood.CollectionType,
-                        flood.Collection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(flood.Collection)
-                            : null,
-                        flood.MultiCollection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(flood.MultiCollection)
-                            : null,
-                        flood.SmartCollection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(flood.SmartCollection)
-                            : null,
-                        flood.MediaItem switch
-                        {
-                            Show show => MediaItems.Mapper.ProjectToViewModel(show),
-                            Season season => MediaItems.Mapper.ProjectToViewModel(season),
-                            Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
-                            _ => null
-                        },
-                        flood.PlaybackOrder,
-                        flood.CustomTitle,
-                        flood.GuideMode,
-                        flood.PreRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(flood.PreRollFiller)
-                            : null,
-                        flood.MidRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(flood.MidRollFiller)
-                            : null,
-                        flood.PostRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(flood.PostRollFiller)
-                            : null,
-                        flood.TailFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(flood.TailFiller)
-                            : null,
-                        flood.FallbackFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(flood.FallbackFiller)
-                            : null),
-                ProgramScheduleItemMultiple multiple =>
-                    new ProgramScheduleItemMultipleViewModel(
-                        multiple.Id,
-                        multiple.Index,
-                        multiple.StartType,
-                        multiple.StartTime,
-                        multiple.CollectionType,
-                        multiple.Collection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(multiple.Collection)
-                            : null,
-                        multiple.MultiCollection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(multiple.MultiCollection)
-                            : null,
-                        multiple.SmartCollection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(multiple.SmartCollection)
-                            : null,
-                        multiple.MediaItem switch
-                        {
-                            Show show => MediaItems.Mapper.ProjectToViewModel(show),
-                            Season season => MediaItems.Mapper.ProjectToViewModel(season),
-                            Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
-                            _ => null
-                        },
-                        multiple.PlaybackOrder,
-                        multiple.Count,
-                        multiple.CustomTitle,
-                        multiple.GuideMode,
-                        multiple.PreRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(multiple.PreRollFiller)
-                            : null,
-                        multiple.MidRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(multiple.MidRollFiller)
-                            : null,
-                        multiple.PostRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(multiple.PostRollFiller)
-                            : null,
-                        multiple.TailFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(multiple.TailFiller)
-                            : null,
-                        multiple.FallbackFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(multiple.FallbackFiller)
-                            : null),
-                ProgramScheduleItemOne one =>
-                    new ProgramScheduleItemOneViewModel(
-                        one.Id,
-                        one.Index,
-                        one.StartType,
-                        one.StartTime,
-                        one.CollectionType,
-                        one.Collection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(one.Collection)
-                            : null,
-                        one.MultiCollection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(one.MultiCollection)
-                            : null,
-                        one.SmartCollection != null
-                            ? MediaCollections.Mapper.ProjectToViewModel(one.SmartCollection)
-                            : null,
-                        one.MediaItem switch
-                        {
-                            Show show => MediaItems.Mapper.ProjectToViewModel(show),
-                            Season season => MediaItems.Mapper.ProjectToViewModel(season),
-                            Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
-                            _ => null
-                        },
-                        one.PlaybackOrder,
-                        one.CustomTitle,
-                        one.GuideMode,
-                        one.PreRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(one.PreRollFiller)
-                            : null,
-                        one.MidRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(one.MidRollFiller)
-                            : null,
-                        one.PostRollFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(one.PostRollFiller)
-                            : null,
-                        one.TailFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(one.TailFiller)
-                            : null,
-                        one.FallbackFiller != null
-                            ? Filler.Mapper.ProjectToViewModel(one.FallbackFiller)
-                            : null),
-                _ => throw new NotSupportedException(
-                    $"Unsupported program schedule item type {programScheduleItem.GetType().Name}")
-            };
-    }
-}
+    internal static ProgramScheduleItemViewModel ProjectToViewModel(ProgramScheduleItem programScheduleItem) =>
+        programScheduleItem switch
+        {
+            ProgramScheduleItemDuration duration =>
+                new ProgramScheduleItemDurationViewModel(
+                    duration.Id,
+                    duration.Index,
+                    duration.StartType,
+                    duration.StartTime,
+                    duration.CollectionType,
+                    duration.Collection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(duration.Collection)
+                        : null,
+                    duration.MultiCollection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(duration.MultiCollection)
+                        : null,
+                    duration.SmartCollection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(duration.SmartCollection)
+                        : null,
+                    duration.MediaItem switch
+                    {
+                        Show show => MediaItems.Mapper.ProjectToViewModel(show),
+                        Season season => MediaItems.Mapper.ProjectToViewModel(season),
+                        Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
+                        _ => null
+                    },
+                    duration.PlaybackOrder,
+                    duration.PlayoutDuration,
+                    duration.TailMode,
+                    duration.CustomTitle,
+                    duration.GuideMode,
+                    duration.PreRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(duration.PreRollFiller)
+                        : null,
+                    duration.MidRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(duration.MidRollFiller)
+                        : null,
+                    duration.PostRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(duration.PostRollFiller)
+                        : null,
+                    duration.TailFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(duration.TailFiller)
+                        : null,
+                    duration.FallbackFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(duration.FallbackFiller)
+                        : null),
+            ProgramScheduleItemFlood flood =>
+                new ProgramScheduleItemFloodViewModel(
+                    flood.Id,
+                    flood.Index,
+                    flood.StartType,
+                    flood.StartTime,
+                    flood.CollectionType,
+                    flood.Collection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(flood.Collection)
+                        : null,
+                    flood.MultiCollection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(flood.MultiCollection)
+                        : null,
+                    flood.SmartCollection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(flood.SmartCollection)
+                        : null,
+                    flood.MediaItem switch
+                    {
+                        Show show => MediaItems.Mapper.ProjectToViewModel(show),
+                        Season season => MediaItems.Mapper.ProjectToViewModel(season),
+                        Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
+                        _ => null
+                    },
+                    flood.PlaybackOrder,
+                    flood.CustomTitle,
+                    flood.GuideMode,
+                    flood.PreRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(flood.PreRollFiller)
+                        : null,
+                    flood.MidRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(flood.MidRollFiller)
+                        : null,
+                    flood.PostRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(flood.PostRollFiller)
+                        : null,
+                    flood.TailFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(flood.TailFiller)
+                        : null,
+                    flood.FallbackFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(flood.FallbackFiller)
+                        : null),
+            ProgramScheduleItemMultiple multiple =>
+                new ProgramScheduleItemMultipleViewModel(
+                    multiple.Id,
+                    multiple.Index,
+                    multiple.StartType,
+                    multiple.StartTime,
+                    multiple.CollectionType,
+                    multiple.Collection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(multiple.Collection)
+                        : null,
+                    multiple.MultiCollection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(multiple.MultiCollection)
+                        : null,
+                    multiple.SmartCollection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(multiple.SmartCollection)
+                        : null,
+                    multiple.MediaItem switch
+                    {
+                        Show show => MediaItems.Mapper.ProjectToViewModel(show),
+                        Season season => MediaItems.Mapper.ProjectToViewModel(season),
+                        Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
+                        _ => null
+                    },
+                    multiple.PlaybackOrder,
+                    multiple.Count,
+                    multiple.CustomTitle,
+                    multiple.GuideMode,
+                    multiple.PreRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(multiple.PreRollFiller)
+                        : null,
+                    multiple.MidRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(multiple.MidRollFiller)
+                        : null,
+                    multiple.PostRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(multiple.PostRollFiller)
+                        : null,
+                    multiple.TailFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(multiple.TailFiller)
+                        : null,
+                    multiple.FallbackFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(multiple.FallbackFiller)
+                        : null),
+            ProgramScheduleItemOne one =>
+                new ProgramScheduleItemOneViewModel(
+                    one.Id,
+                    one.Index,
+                    one.StartType,
+                    one.StartTime,
+                    one.CollectionType,
+                    one.Collection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(one.Collection)
+                        : null,
+                    one.MultiCollection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(one.MultiCollection)
+                        : null,
+                    one.SmartCollection != null
+                        ? MediaCollections.Mapper.ProjectToViewModel(one.SmartCollection)
+                        : null,
+                    one.MediaItem switch
+                    {
+                        Show show => MediaItems.Mapper.ProjectToViewModel(show),
+                        Season season => MediaItems.Mapper.ProjectToViewModel(season),
+                        Artist artist => MediaItems.Mapper.ProjectToViewModel(artist),
+                        _ => null
+                    },
+                    one.PlaybackOrder,
+                    one.CustomTitle,
+                    one.GuideMode,
+                    one.PreRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(one.PreRollFiller)
+                        : null,
+                    one.MidRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(one.MidRollFiller)
+                        : null,
+                    one.PostRollFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(one.PostRollFiller)
+                        : null,
+                    one.TailFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(one.TailFiller)
+                        : null,
+                    one.FallbackFiller != null
+                        ? Filler.Mapper.ProjectToViewModel(one.FallbackFiller)
+                        : null),
+            _ => throw new NotSupportedException(
+                $"Unsupported program schedule item type {programScheduleItem.GetType().Name}")
+        };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs
index 8768b0ca6..a74b846fe 100644
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemDurationViewModel.cs
@@ -1,57 +1,55 @@
-using System;
-using ErsatzTV.Application.Filler;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.ProgramSchedules
-{
-    public record ProgramScheduleItemDurationViewModel : ProgramScheduleItemViewModel
-    {
-        public ProgramScheduleItemDurationViewModel(
-            int id,
-            int index,
-            StartType startType,
-            TimeSpan? startTime,
-            ProgramScheduleItemCollectionType collectionType,
-            MediaCollectionViewModel collection,
-            MultiCollectionViewModel multiCollection,
-            SmartCollectionViewModel smartCollection,
-            NamedMediaItemViewModel mediaItem,
-            PlaybackOrder playbackOrder,
-            TimeSpan playoutDuration,
-            TailMode tailMode,
-            string customTitle,
-            GuideMode guideMode,
-            FillerPresetViewModel preRollFiller,
-            FillerPresetViewModel midRollFiller,
-            FillerPresetViewModel postRollFiller,
-            FillerPresetViewModel tailFiller,
-            FillerPresetViewModel fallbackFiller) : base(
-            id,
-            index,
-            startType,
-            startTime,
-            PlayoutMode.Duration,
-            collectionType,
-            collection,
-            multiCollection,
-            smartCollection,
-            mediaItem,
-            playbackOrder,
-            customTitle,
-            guideMode,
-            preRollFiller,
-            midRollFiller,
-            postRollFiller,
-            tailFiller,
-            fallbackFiller)
-        {
-            PlayoutDuration = playoutDuration;
-            TailMode = tailMode;
-        }
+namespace ErsatzTV.Application.ProgramSchedules;
 
-        public TimeSpan PlayoutDuration { get; }
-        public TailMode TailMode { get; }
+public record ProgramScheduleItemDurationViewModel : ProgramScheduleItemViewModel
+{
+    public ProgramScheduleItemDurationViewModel(
+        int id,
+        int index,
+        StartType startType,
+        TimeSpan? startTime,
+        ProgramScheduleItemCollectionType collectionType,
+        MediaCollectionViewModel collection,
+        MultiCollectionViewModel multiCollection,
+        SmartCollectionViewModel smartCollection,
+        NamedMediaItemViewModel mediaItem,
+        PlaybackOrder playbackOrder,
+        TimeSpan playoutDuration,
+        TailMode tailMode,
+        string customTitle,
+        GuideMode guideMode,
+        FillerPresetViewModel preRollFiller,
+        FillerPresetViewModel midRollFiller,
+        FillerPresetViewModel postRollFiller,
+        FillerPresetViewModel tailFiller,
+        FillerPresetViewModel fallbackFiller) : base(
+        id,
+        index,
+        startType,
+        startTime,
+        PlayoutMode.Duration,
+        collectionType,
+        collection,
+        multiCollection,
+        smartCollection,
+        mediaItem,
+        playbackOrder,
+        customTitle,
+        guideMode,
+        preRollFiller,
+        midRollFiller,
+        postRollFiller,
+        tailFiller,
+        fallbackFiller)
+    {
+        PlayoutDuration = playoutDuration;
+        TailMode = tailMode;
     }
-}
+
+    public TimeSpan PlayoutDuration { get; }
+    public TailMode TailMode { get; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs
index 434deec86..f3fd11e24 100644
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemFloodViewModel.cs
@@ -1,50 +1,48 @@
-using System;
-using ErsatzTV.Application.Filler;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.ProgramSchedules
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record ProgramScheduleItemFloodViewModel : ProgramScheduleItemViewModel
 {
-    public record ProgramScheduleItemFloodViewModel : ProgramScheduleItemViewModel
+    public ProgramScheduleItemFloodViewModel(
+        int id,
+        int index,
+        StartType startType,
+        TimeSpan? startTime,
+        ProgramScheduleItemCollectionType collectionType,
+        MediaCollectionViewModel collection,
+        MultiCollectionViewModel multiCollection,
+        SmartCollectionViewModel smartCollection,
+        NamedMediaItemViewModel mediaItem,
+        PlaybackOrder playbackOrder,
+        string customTitle,
+        GuideMode guideMode,
+        FillerPresetViewModel preRollFiller,
+        FillerPresetViewModel midRollFiller,
+        FillerPresetViewModel postRollFiller,
+        FillerPresetViewModel tailFiller,
+        FillerPresetViewModel fallbackFiller) : base(
+        id,
+        index,
+        startType,
+        startTime,
+        PlayoutMode.Flood,
+        collectionType,
+        collection,
+        multiCollection,
+        smartCollection,
+        mediaItem,
+        playbackOrder,
+        customTitle,
+        guideMode,
+        preRollFiller,
+        midRollFiller,
+        postRollFiller,
+        tailFiller,
+        fallbackFiller)
     {
-        public ProgramScheduleItemFloodViewModel(
-            int id,
-            int index,
-            StartType startType,
-            TimeSpan? startTime,
-            ProgramScheduleItemCollectionType collectionType,
-            MediaCollectionViewModel collection,
-            MultiCollectionViewModel multiCollection,
-            SmartCollectionViewModel smartCollection,
-            NamedMediaItemViewModel mediaItem,
-            PlaybackOrder playbackOrder,
-            string customTitle,
-            GuideMode guideMode,
-            FillerPresetViewModel preRollFiller,
-            FillerPresetViewModel midRollFiller,
-            FillerPresetViewModel postRollFiller,
-            FillerPresetViewModel tailFiller,
-            FillerPresetViewModel fallbackFiller) : base(
-            id,
-            index,
-            startType,
-            startTime,
-            PlayoutMode.Flood,
-            collectionType,
-            collection,
-            multiCollection,
-            smartCollection,
-            mediaItem,
-            playbackOrder,
-            customTitle,
-            guideMode,
-            preRollFiller,
-            midRollFiller,
-            postRollFiller,
-            tailFiller,
-            fallbackFiller)
-        {
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs
index 1f8c149d5..7430c1875 100644
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemMultipleViewModel.cs
@@ -1,52 +1,50 @@
-using System;
-using ErsatzTV.Application.Filler;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.ProgramSchedules
-{
-    public record ProgramScheduleItemMultipleViewModel : ProgramScheduleItemViewModel
-    {
-        public ProgramScheduleItemMultipleViewModel(
-            int id,
-            int index,
-            StartType startType,
-            TimeSpan? startTime,
-            ProgramScheduleItemCollectionType collectionType,
-            MediaCollectionViewModel collection,
-            MultiCollectionViewModel multiCollection,
-            SmartCollectionViewModel smartCollection,
-            NamedMediaItemViewModel mediaItem,
-            PlaybackOrder playbackOrder,
-            int count,
-            string customTitle,
-            GuideMode guideMode,
-            FillerPresetViewModel preRollFiller,
-            FillerPresetViewModel midRollFiller,
-            FillerPresetViewModel postRollFiller,
-            FillerPresetViewModel tailFiller,
-            FillerPresetViewModel fallbackFiller) : base(
-            id,
-            index,
-            startType,
-            startTime,
-            PlayoutMode.Multiple,
-            collectionType,
-            collection,
-            multiCollection,
-            smartCollection,
-            mediaItem,
-            playbackOrder,
-            customTitle,
-            guideMode,
-            preRollFiller,
-            midRollFiller,
-            postRollFiller,
-            tailFiller,
-            fallbackFiller) =>
-            Count = count;
+namespace ErsatzTV.Application.ProgramSchedules;
 
-        public int Count { get; }
-    }
-}
+public record ProgramScheduleItemMultipleViewModel : ProgramScheduleItemViewModel
+{
+    public ProgramScheduleItemMultipleViewModel(
+        int id,
+        int index,
+        StartType startType,
+        TimeSpan? startTime,
+        ProgramScheduleItemCollectionType collectionType,
+        MediaCollectionViewModel collection,
+        MultiCollectionViewModel multiCollection,
+        SmartCollectionViewModel smartCollection,
+        NamedMediaItemViewModel mediaItem,
+        PlaybackOrder playbackOrder,
+        int count,
+        string customTitle,
+        GuideMode guideMode,
+        FillerPresetViewModel preRollFiller,
+        FillerPresetViewModel midRollFiller,
+        FillerPresetViewModel postRollFiller,
+        FillerPresetViewModel tailFiller,
+        FillerPresetViewModel fallbackFiller) : base(
+        id,
+        index,
+        startType,
+        startTime,
+        PlayoutMode.Multiple,
+        collectionType,
+        collection,
+        multiCollection,
+        smartCollection,
+        mediaItem,
+        playbackOrder,
+        customTitle,
+        guideMode,
+        preRollFiller,
+        midRollFiller,
+        postRollFiller,
+        tailFiller,
+        fallbackFiller) =>
+        Count = count;
+
+    public int Count { get; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs
index 08d80ecb1..e7577bc8c 100644
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemOneViewModel.cs
@@ -1,50 +1,48 @@
-using System;
-using ErsatzTV.Application.Filler;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.ProgramSchedules
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record ProgramScheduleItemOneViewModel : ProgramScheduleItemViewModel
 {
-    public record ProgramScheduleItemOneViewModel : ProgramScheduleItemViewModel
+    public ProgramScheduleItemOneViewModel(
+        int id,
+        int index,
+        StartType startType,
+        TimeSpan? startTime,
+        ProgramScheduleItemCollectionType collectionType,
+        MediaCollectionViewModel collection,
+        MultiCollectionViewModel multiCollection,
+        SmartCollectionViewModel smartCollection,
+        NamedMediaItemViewModel mediaItem,
+        PlaybackOrder playbackOrder,
+        string customTitle,
+        GuideMode guideMode,
+        FillerPresetViewModel preRollFiller,
+        FillerPresetViewModel midRollFiller,
+        FillerPresetViewModel postRollFiller,
+        FillerPresetViewModel tailFiller,
+        FillerPresetViewModel fallbackFiller) : base(
+        id,
+        index,
+        startType,
+        startTime,
+        PlayoutMode.One,
+        collectionType,
+        collection,
+        multiCollection,
+        smartCollection,
+        mediaItem,
+        playbackOrder,
+        customTitle,
+        guideMode,
+        preRollFiller,
+        midRollFiller,
+        postRollFiller,
+        tailFiller,
+        fallbackFiller)
     {
-        public ProgramScheduleItemOneViewModel(
-            int id,
-            int index,
-            StartType startType,
-            TimeSpan? startTime,
-            ProgramScheduleItemCollectionType collectionType,
-            MediaCollectionViewModel collection,
-            MultiCollectionViewModel multiCollection,
-            SmartCollectionViewModel smartCollection,
-            NamedMediaItemViewModel mediaItem,
-            PlaybackOrder playbackOrder,
-            string customTitle,
-            GuideMode guideMode,
-            FillerPresetViewModel preRollFiller,
-            FillerPresetViewModel midRollFiller,
-            FillerPresetViewModel postRollFiller,
-            FillerPresetViewModel tailFiller,
-            FillerPresetViewModel fallbackFiller) : base(
-            id,
-            index,
-            startType,
-            startTime,
-            PlayoutMode.One,
-            collectionType,
-            collection,
-            multiCollection,
-            smartCollection,
-            mediaItem,
-            playbackOrder,
-            customTitle,
-            guideMode,
-            preRollFiller,
-            midRollFiller,
-            postRollFiller,
-            tailFiller,
-            fallbackFiller)
-        {
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs
index cd84d8bf4..558384115 100644
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs
@@ -1,45 +1,43 @@
-using System;
-using ErsatzTV.Application.Filler;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.ProgramSchedules
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public abstract record ProgramScheduleItemViewModel(
+    int Id,
+    int Index,
+    StartType StartType,
+    TimeSpan? StartTime,
+    PlayoutMode PlayoutMode,
+    ProgramScheduleItemCollectionType CollectionType,
+    MediaCollectionViewModel Collection,
+    MultiCollectionViewModel MultiCollection,
+    SmartCollectionViewModel SmartCollection,
+    NamedMediaItemViewModel MediaItem,
+    PlaybackOrder PlaybackOrder,
+    string CustomTitle,
+    GuideMode GuideMode,
+    FillerPresetViewModel PreRollFiller,
+    FillerPresetViewModel MidRollFiller,
+    FillerPresetViewModel PostRollFiller,
+    FillerPresetViewModel TailFiller,
+    FillerPresetViewModel FallbackFiller)
 {
-    public abstract record ProgramScheduleItemViewModel(
-        int Id,
-        int Index,
-        StartType StartType,
-        TimeSpan? StartTime,
-        PlayoutMode PlayoutMode,
-        ProgramScheduleItemCollectionType CollectionType,
-        MediaCollectionViewModel Collection,
-        MultiCollectionViewModel MultiCollection,
-        SmartCollectionViewModel SmartCollection,
-        NamedMediaItemViewModel MediaItem,
-        PlaybackOrder PlaybackOrder,
-        string CustomTitle,
-        GuideMode GuideMode,
-        FillerPresetViewModel PreRollFiller,
-        FillerPresetViewModel MidRollFiller,
-        FillerPresetViewModel PostRollFiller,
-        FillerPresetViewModel TailFiller,
-        FillerPresetViewModel FallbackFiller)
+    public string Name => CollectionType switch
     {
-        public string Name => CollectionType switch
-        {
-            ProgramScheduleItemCollectionType.Collection => Collection?.Name,
-            ProgramScheduleItemCollectionType.TelevisionShow =>
-                MediaItem?.Name, // $"{TelevisionShow?.Title} ({TelevisionShow?.Year})",
-            ProgramScheduleItemCollectionType.TelevisionSeason =>
-                MediaItem?.Name, // $"{TelevisionSeason?.Title} ({TelevisionSeason?.Plot})",
-            ProgramScheduleItemCollectionType.Artist =>
-                MediaItem?.Name,
-            ProgramScheduleItemCollectionType.MultiCollection =>
-                MultiCollection?.Name,
-            ProgramScheduleItemCollectionType.SmartCollection =>
-                SmartCollection?.Name,
-            _ => string.Empty
-        };
-    }
-}
+        ProgramScheduleItemCollectionType.Collection => Collection?.Name,
+        ProgramScheduleItemCollectionType.TelevisionShow =>
+            MediaItem?.Name, // $"{TelevisionShow?.Title} ({TelevisionShow?.Year})",
+        ProgramScheduleItemCollectionType.TelevisionSeason =>
+            MediaItem?.Name, // $"{TelevisionSeason?.Title} ({TelevisionSeason?.Plot})",
+        ProgramScheduleItemCollectionType.Artist =>
+            MediaItem?.Name,
+        ProgramScheduleItemCollectionType.MultiCollection =>
+            MultiCollection?.Name,
+        ProgramScheduleItemCollectionType.SmartCollection =>
+            SmartCollection?.Name,
+        _ => string.Empty
+    };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleViewModel.cs b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleViewModel.cs
index 8840e1859..0202e221e 100644
--- a/ErsatzTV.Application/ProgramSchedules/ProgramScheduleViewModel.cs
+++ b/ErsatzTV.Application/ProgramSchedules/ProgramScheduleViewModel.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Application.ProgramSchedules
-{
-    public record ProgramScheduleViewModel(
-        int Id,
-        string Name,
-        bool KeepMultiPartEpisodesTogether,
-        bool TreatCollectionsAsShows,
-        bool ShuffleScheduleItems);
-}
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record ProgramScheduleViewModel(
+    int Id,
+    string Name,
+    bool KeepMultiPartEpisodesTogether,
+    bool TreatCollectionsAsShows,
+    bool ShuffleScheduleItems);
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedules.cs b/ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedules.cs
index db8553438..ce8d78131 100644
--- a/ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedules.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedules.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.ProgramSchedules;
 
-namespace ErsatzTV.Application.ProgramSchedules.Queries
-{
-    public record GetAllProgramSchedules : IRequest<List<ProgramScheduleViewModel>>;
-}
+public record GetAllProgramSchedules : IRequest<List<ProgramScheduleViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedulesHandler.cs b/ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedulesHandler.cs
index 3d024ac9d..d2879f0ea 100644
--- a/ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedulesHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Queries/GetAllProgramSchedulesHandler.cs
@@ -1,33 +1,28 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.ProgramSchedules.Queries
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class GetAllProgramSchedulesHandler : IRequestHandler<GetAllProgramSchedules, List<ProgramScheduleViewModel>>
 {
-    public class GetAllProgramSchedulesHandler : IRequestHandler<GetAllProgramSchedules, List<ProgramScheduleViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllProgramSchedulesHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<ProgramScheduleViewModel>> Handle(
+        GetAllProgramSchedules request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllProgramSchedulesHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<ProgramScheduleViewModel>> Handle(
-            GetAllProgramSchedules request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.ProgramSchedules
-                .Map(
-                    ps => new ProgramScheduleViewModel(
-                        ps.Id,
-                        ps.Name,
-                        ps.KeepMultiPartEpisodesTogether,
-                        ps.TreatCollectionsAsShows,
-                        ps.ShuffleScheduleItems))
-                .ToListAsync(cancellationToken);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.ProgramSchedules
+            .Map(
+                ps => new ProgramScheduleViewModel(
+                    ps.Id,
+                    ps.Name,
+                    ps.KeepMultiPartEpisodesTogether,
+                    ps.TreatCollectionsAsShows,
+                    ps.ShuffleScheduleItems))
+            .ToListAsync(cancellationToken);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleById.cs b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleById.cs
index 62265d366..cd0188d21 100644
--- a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleById.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.ProgramSchedules;
 
-namespace ErsatzTV.Application.ProgramSchedules.Queries
-{
-    public record GetProgramScheduleById(int Id) : IRequest<Option<ProgramScheduleViewModel>>;
-}
+public record GetProgramScheduleById(int Id) : IRequest<Option<ProgramScheduleViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleByIdHandler.cs b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleByIdHandler.cs
index b46664b5b..ff08a51b5 100644
--- a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleByIdHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleByIdHandler.cs
@@ -1,30 +1,25 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.ProgramSchedules.Mapper;
 
-namespace ErsatzTV.Application.ProgramSchedules.Queries
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class GetProgramScheduleByIdHandler :
+    IRequestHandler<GetProgramScheduleById, Option<ProgramScheduleViewModel>>
 {
-    public class GetProgramScheduleByIdHandler :
-        IRequestHandler<GetProgramScheduleById, Option<ProgramScheduleViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetProgramScheduleByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Option<ProgramScheduleViewModel>> Handle(
+        GetProgramScheduleById request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetProgramScheduleByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Option<ProgramScheduleViewModel>> Handle(
-            GetProgramScheduleById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            return await dbContext.ProgramSchedules
-                .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id)
-                .MapT(ProjectToViewModel);
-        }
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        return await dbContext.ProgramSchedules
+            .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id)
+            .MapT(ProjectToViewModel);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItems.cs b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItems.cs
index 9659d054c..9cadcb96e 100644
--- a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItems.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItems.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.ProgramSchedules;
 
-namespace ErsatzTV.Application.ProgramSchedules.Queries
-{
-    public record GetProgramScheduleItems(int Id) : IRequest<List<ProgramScheduleItemViewModel>>;
-}
+public record GetProgramScheduleItems(int Id) : IRequest<List<ProgramScheduleItemViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs
index b5123bd8b..3bbb9f5c6 100644
--- a/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsHandler.cs
@@ -1,84 +1,77 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.ProgramSchedules.Mapper;
 
-namespace ErsatzTV.Application.ProgramSchedules.Queries
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class GetProgramScheduleItemsHandler :
+    IRequestHandler<GetProgramScheduleItems, List<ProgramScheduleItemViewModel>>
 {
-    public class GetProgramScheduleItemsHandler :
-        IRequestHandler<GetProgramScheduleItems, List<ProgramScheduleItemViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetProgramScheduleItemsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<ProgramScheduleItemViewModel>> Handle(
+        GetProgramScheduleItems request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
-        public GetProgramScheduleItemsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        Option<ProgramSchedule> maybeProgramSchedule =
+            await dbContext.ProgramSchedules.SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id);
 
-        public async Task<List<ProgramScheduleItemViewModel>> Handle(
-            GetProgramScheduleItems request,
-            CancellationToken cancellationToken)
+        return await dbContext.ProgramScheduleItems
+            .Filter(psi => psi.ProgramScheduleId == request.Id)
+            .Include(i => i.Collection)
+            .Include(i => i.MultiCollection)
+            .Include(i => i.SmartCollection)
+            .Include(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(i => i.MediaItem)
+            .ThenInclude(i => (i as Season).SeasonMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(i => i.MediaItem)
+            .ThenInclude(i => (i as Season).Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(i => i.MediaItem)
+            .ThenInclude(i => (i as Show).ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(i => i.MediaItem)
+            .ThenInclude(i => (i as Artist).ArtistMetadata)
+            .ThenInclude(am => am.Artwork)
+            .Include(i => i.PreRollFiller)
+            .Include(i => i.MidRollFiller)
+            .Include(i => i.PostRollFiller)
+            .Include(i => i.TailFiller)
+            .Include(i => i.FallbackFiller)
+            .ToListAsync(cancellationToken)
+            .Map(
+                programScheduleItems => programScheduleItems.Map(ProjectToViewModel)
+                    .Map(psi => EnforceProperties(maybeProgramSchedule, psi)).ToList());
+    }
+
+    // shuffled schedule items supports a limited set of properly values
+    private ProgramScheduleItemViewModel EnforceProperties(
+        Option<ProgramSchedule> maybeProgramSchedule,
+        ProgramScheduleItemViewModel item)
+    {
+        foreach (ProgramSchedule programSchedule in maybeProgramSchedule)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-
-            Option<ProgramSchedule> maybeProgramSchedule =
-                await dbContext.ProgramSchedules.SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id);
-
-            return await dbContext.ProgramScheduleItems
-                .Filter(psi => psi.ProgramScheduleId == request.Id)
-                .Include(i => i.Collection)
-                .Include(i => i.MultiCollection)
-                .Include(i => i.SmartCollection)
-                .Include(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(i => i.MediaItem)
-                .ThenInclude(i => (i as Season).SeasonMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(i => i.MediaItem)
-                .ThenInclude(i => (i as Season).Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(i => i.MediaItem)
-                .ThenInclude(i => (i as Show).ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(i => i.MediaItem)
-                .ThenInclude(i => (i as Artist).ArtistMetadata)
-                .ThenInclude(am => am.Artwork)
-                .Include(i => i.PreRollFiller)
-                .Include(i => i.MidRollFiller)
-                .Include(i => i.PostRollFiller)
-                .Include(i => i.TailFiller)
-                .Include(i => i.FallbackFiller)
-                .ToListAsync(cancellationToken)
-                .Map(
-                    programScheduleItems => programScheduleItems.Map(ProjectToViewModel)
-                        .Map(psi => EnforceProperties(maybeProgramSchedule, psi)).ToList());
-        }
-
-        // shuffled schedule items supports a limited set of properly values
-        private ProgramScheduleItemViewModel EnforceProperties(
-            Option<ProgramSchedule> maybeProgramSchedule,
-            ProgramScheduleItemViewModel item)
-        {
-            foreach (ProgramSchedule programSchedule in maybeProgramSchedule)
+            if (programSchedule.ShuffleScheduleItems)
             {
-                if (programSchedule.ShuffleScheduleItems)
+                item = item with { StartType = StartType.Dynamic };
+                if (item.PlayoutMode == PlayoutMode.Flood)
                 {
-                    item = item with { StartType = StartType.Dynamic };
-                    if (item.PlayoutMode == PlayoutMode.Flood)
-                    {
-                        item = item with { PlayoutMode = PlayoutMode.One };
-                    }
+                    item = item with { PlayoutMode = PlayoutMode.One };
                 }
             }
-
-            return item;
         }
+
+        return item;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Resolutions/FFmpegProfileResolutionViewModel.cs b/ErsatzTV.Application/Resolutions/FFmpegProfileResolutionViewModel.cs
index 281055252..84eb02f97 100644
--- a/ErsatzTV.Application/Resolutions/FFmpegProfileResolutionViewModel.cs
+++ b/ErsatzTV.Application/Resolutions/FFmpegProfileResolutionViewModel.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Application.Resolutions
-{
-    public record ResolutionViewModel(int Id, string Name, int Width, int Height);
-}
+namespace ErsatzTV.Application.Resolutions;
+
+public record ResolutionViewModel(int Id, string Name, int Width, int Height);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Resolutions/Mapper.cs b/ErsatzTV.Application/Resolutions/Mapper.cs
index 47f6da43c..175d2b645 100644
--- a/ErsatzTV.Application/Resolutions/Mapper.cs
+++ b/ErsatzTV.Application/Resolutions/Mapper.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Resolutions
+namespace ErsatzTV.Application.Resolutions;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
-            new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);
-    }
-}
+    internal static ResolutionViewModel ProjectToViewModel(Resolution resolution) =>
+        new(resolution.Id, resolution.Name, resolution.Width, resolution.Height);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Resolutions/Queries/GetAllResolutions.cs b/ErsatzTV.Application/Resolutions/Queries/GetAllResolutions.cs
index ff9ee80ac..95350905b 100644
--- a/ErsatzTV.Application/Resolutions/Queries/GetAllResolutions.cs
+++ b/ErsatzTV.Application/Resolutions/Queries/GetAllResolutions.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Resolutions;
 
-namespace ErsatzTV.Application.Resolutions.Queries
-{
-    public record GetAllResolutions : IRequest<List<ResolutionViewModel>>;
-}
+public record GetAllResolutions : IRequest<List<ResolutionViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Resolutions/Queries/GetAllResolutionsHandler.cs b/ErsatzTV.Application/Resolutions/Queries/GetAllResolutionsHandler.cs
index b702c8694..8780c8895 100644
--- a/ErsatzTV.Application/Resolutions/Queries/GetAllResolutionsHandler.cs
+++ b/ErsatzTV.Application/Resolutions/Queries/GetAllResolutionsHandler.cs
@@ -1,30 +1,23 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Resolutions.Mapper;
 
-namespace ErsatzTV.Application.Resolutions.Queries
+namespace ErsatzTV.Application.Resolutions;
+
+public class GetAllResolutionsHandler : IRequestHandler<GetAllResolutions, List<ResolutionViewModel>>
 {
-    public class GetAllResolutionsHandler : IRequestHandler<GetAllResolutions, List<ResolutionViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllResolutionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<ResolutionViewModel>> Handle(
+        GetAllResolutions request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllResolutionsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<ResolutionViewModel>> Handle(
-            GetAllResolutions request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Resolutions
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Resolutions
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Commands/RebuildSearchIndex.cs b/ErsatzTV.Application/Search/Commands/RebuildSearchIndex.cs
index 7eafb3e17..c74fb1185 100644
--- a/ErsatzTV.Application/Search/Commands/RebuildSearchIndex.cs
+++ b/ErsatzTV.Application/Search/Commands/RebuildSearchIndex.cs
@@ -1,6 +1,3 @@
-using LanguageExt;
+namespace ErsatzTV.Application.Search;
 
-namespace ErsatzTV.Application.Search.Commands
-{
-    public record RebuildSearchIndex : MediatR.IRequest<Unit>, IBackgroundServiceRequest;
-}
+public record RebuildSearchIndex : MediatR.IRequest<Unit>, IBackgroundServiceRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Commands/RebuildSearchIndexHandler.cs b/ErsatzTV.Application/Search/Commands/RebuildSearchIndexHandler.cs
index 360f60a65..195acc2ce 100644
--- a/ErsatzTV.Application/Search/Commands/RebuildSearchIndexHandler.cs
+++ b/ErsatzTV.Application/Search/Commands/RebuildSearchIndexHandler.cs
@@ -1,64 +1,58 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Application.Search.Commands
+namespace ErsatzTV.Application.Search;
+
+public class RebuildSearchIndexHandler : MediatR.IRequestHandler<RebuildSearchIndex, Unit>
 {
-    public class RebuildSearchIndexHandler : MediatR.IRequestHandler<RebuildSearchIndex, Unit>
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILogger<RebuildSearchIndexHandler> _logger;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+
+    public RebuildSearchIndexHandler(
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        IConfigElementRepository configElementRepository,
+        ILocalFileSystem localFileSystem,
+        ILogger<RebuildSearchIndexHandler> logger)
     {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILogger<RebuildSearchIndexHandler> _logger;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
-
-        public RebuildSearchIndexHandler(
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            IConfigElementRepository configElementRepository,
-            ILocalFileSystem localFileSystem,
-            ILogger<RebuildSearchIndexHandler> logger)
-        {
-            _searchIndex = searchIndex;
-            _logger = logger;
-            _searchRepository = searchRepository;
-            _configElementRepository = configElementRepository;
-            _localFileSystem = localFileSystem;
-        }
-
-        public async Task<Unit> Handle(RebuildSearchIndex request, CancellationToken cancellationToken)
-        {
-            bool indexFolderExists = Directory.Exists(FileSystemLayout.SearchIndexFolder);
-
-            await _searchIndex.Initialize(_localFileSystem);
-
-            if (!indexFolderExists ||
-                await _configElementRepository.GetValue<int>(ConfigElementKey.SearchIndexVersion) <
-                _searchIndex.Version)
-            {
-                _logger.LogInformation("Migrating search index to version {Version}", _searchIndex.Version);
-
-                List<int> itemIds = await _searchRepository.GetItemIdsToIndex();
-                await _searchIndex.Rebuild(_searchRepository, itemIds);
-
-                await _configElementRepository.Upsert(ConfigElementKey.SearchIndexVersion, _searchIndex.Version);
-
-                _logger.LogInformation("Done migrating search index");
-            }
-            else
-            {
-                _logger.LogInformation("Search index is already version {Version}", _searchIndex.Version);
-            }
-
-            return Unit.Default;
-        }
+        _searchIndex = searchIndex;
+        _logger = logger;
+        _searchRepository = searchRepository;
+        _configElementRepository = configElementRepository;
+        _localFileSystem = localFileSystem;
     }
-}
+
+    public async Task<Unit> Handle(RebuildSearchIndex request, CancellationToken cancellationToken)
+    {
+        bool indexFolderExists = Directory.Exists(FileSystemLayout.SearchIndexFolder);
+
+        await _searchIndex.Initialize(_localFileSystem);
+
+        if (!indexFolderExists ||
+            await _configElementRepository.GetValue<int>(ConfigElementKey.SearchIndexVersion) <
+            _searchIndex.Version)
+        {
+            _logger.LogInformation("Migrating search index to version {Version}", _searchIndex.Version);
+
+            List<int> itemIds = await _searchRepository.GetItemIdsToIndex();
+            await _searchIndex.Rebuild(_searchRepository, itemIds);
+
+            await _configElementRepository.Upsert(ConfigElementKey.SearchIndexVersion, _searchIndex.Version);
+
+            _logger.LogInformation("Done migrating search index");
+        }
+        else
+        {
+            _logger.LogInformation("Search index is already version {Version}", _searchIndex.Version);
+        }
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItems.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItems.cs
index f623432d8..5f75f11a1 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItems.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItems.cs
@@ -1,6 +1,3 @@
-using MediatR;
+namespace ErsatzTV.Application.Search;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexAllItems(string Query) : IRequest<SearchResultAllItemsViewModel>;
-}
+public record QuerySearchIndexAllItems(string Query) : IRequest<SearchResultAllItemsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs
index ea479be87..d025948b8 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexAllItemsHandler.cs
@@ -1,36 +1,29 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Search;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class
+    QuerySearchIndexAllItemsHandler : IRequestHandler<QuerySearchIndexAllItems, SearchResultAllItemsViewModel>
 {
-    public class
-        QuerySearchIndexAllItemsHandler : IRequestHandler<QuerySearchIndexAllItems, SearchResultAllItemsViewModel>
-    {
-        private readonly ISearchIndex _searchIndex;
+    private readonly ISearchIndex _searchIndex;
 
-        public QuerySearchIndexAllItemsHandler(ISearchIndex searchIndex) => _searchIndex = searchIndex;
+    public QuerySearchIndexAllItemsHandler(ISearchIndex searchIndex) => _searchIndex = searchIndex;
 
-        public async Task<SearchResultAllItemsViewModel> Handle(
-            QuerySearchIndexAllItems request,
-            CancellationToken cancellationToken) =>
-            new(
-                await GetIds(SearchIndex.MovieType, request.Query),
-                await GetIds(SearchIndex.ShowType, request.Query),
-                await GetIds(SearchIndex.SeasonType, request.Query),
-                await GetIds(SearchIndex.EpisodeType, request.Query),
-                await GetIds(SearchIndex.ArtistType, request.Query),
-                await GetIds(SearchIndex.MusicVideoType, request.Query),
-                await GetIds(SearchIndex.OtherVideoType, request.Query),
-                await GetIds(SearchIndex.SongType, request.Query));
+    public async Task<SearchResultAllItemsViewModel> Handle(
+        QuerySearchIndexAllItems request,
+        CancellationToken cancellationToken) =>
+        new(
+            await GetIds(SearchIndex.MovieType, request.Query),
+            await GetIds(SearchIndex.ShowType, request.Query),
+            await GetIds(SearchIndex.SeasonType, request.Query),
+            await GetIds(SearchIndex.EpisodeType, request.Query),
+            await GetIds(SearchIndex.ArtistType, request.Query),
+            await GetIds(SearchIndex.MusicVideoType, request.Query),
+            await GetIds(SearchIndex.OtherVideoType, request.Query),
+            await GetIds(SearchIndex.SongType, request.Query));
 
-        private Task<List<int>> GetIds(string type, string query) =>
-            _searchIndex.Search($"type:{type} AND ({query})", 0, 0)
-                .Map(result => result.Items.Map(i => i.Id).ToList());
-    }
-}
+    private Task<List<int>> GetIds(string type, string query) =>
+        _searchIndex.Search($"type:{type} AND ({query})", 0, 0)
+            .Map(result => result.Items.Map(i => i.Id).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexArtists.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexArtists.cs
index 1ba2b5114..10aafce28 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexArtists.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexArtists.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Application.MediaCards;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexArtists
-        (string Query, int PageNumber, int PageSize) : IRequest<ArtistCardResultsViewModel>;
-}
+namespace ErsatzTV.Application.Search;
+
+public record QuerySearchIndexArtists
+    (string Query, int PageNumber, int PageSize) : IRequest<ArtistCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexArtistsHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexArtistsHandler.cs
index 126ea4e66..d4c3d0373 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexArtistsHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexArtistsHandler.cs
@@ -1,44 +1,37 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class
+    QuerySearchIndexArtistsHandler : IRequestHandler<QuerySearchIndexArtists, ArtistCardResultsViewModel
+    >
 {
-    public class
-        QuerySearchIndexArtistsHandler : IRequestHandler<QuerySearchIndexArtists, ArtistCardResultsViewModel
-        >
+    private readonly IArtistRepository _artistRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public QuerySearchIndexArtistsHandler(ISearchIndex searchIndex, IArtistRepository artistRepository)
     {
-        private readonly IArtistRepository _artistRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public QuerySearchIndexArtistsHandler(ISearchIndex searchIndex, IArtistRepository artistRepository)
-        {
-            _searchIndex = searchIndex;
-            _artistRepository = artistRepository;
-        }
-
-        public async Task<ArtistCardResultsViewModel> Handle(
-            QuerySearchIndexArtists request,
-            CancellationToken cancellationToken)
-        {
-            SearchResult searchResult = await _searchIndex.Search(
-                request.Query,
-                (request.PageNumber - 1) * request.PageSize,
-                request.PageSize);
-
-            List<ArtistCardViewModel> items = await _artistRepository
-                .GetArtistsForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-
-            return new ArtistCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
-        }
+        _searchIndex = searchIndex;
+        _artistRepository = artistRepository;
     }
-}
+
+    public async Task<ArtistCardResultsViewModel> Handle(
+        QuerySearchIndexArtists request,
+        CancellationToken cancellationToken)
+    {
+        SearchResult searchResult = await _searchIndex.Search(
+            request.Query,
+            (request.PageNumber - 1) * request.PageSize,
+            request.PageSize);
+
+        List<ArtistCardViewModel> items = await _artistRepository
+            .GetArtistsForCards(searchResult.Items.Map(i => i.Id).ToList())
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+
+        return new ArtistCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodes.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodes.cs
index 5d0622865..e733f1887 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodes.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodes.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Application.MediaCards;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexEpisodes
-        (string Query, int PageNumber, int PageSize) : IRequest<TelevisionEpisodeCardResultsViewModel>;
-}
+namespace ErsatzTV.Application.Search;
+
+public record QuerySearchIndexEpisodes
+    (string Query, int PageNumber, int PageSize) : IRequest<TelevisionEpisodeCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodesHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodesHandler.cs
index dea6db740..49f64a3d8 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodesHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexEpisodesHandler.cs
@@ -1,56 +1,49 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class
+    QuerySearchIndexEpisodesHandler : IRequestHandler<QuerySearchIndexEpisodes,
+        TelevisionEpisodeCardResultsViewModel>
 {
-    public class
-        QuerySearchIndexEpisodesHandler : IRequestHandler<QuerySearchIndexEpisodes,
-            TelevisionEpisodeCardResultsViewModel>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public QuerySearchIndexEpisodesHandler(
+        ISearchIndex searchIndex,
+        ITelevisionRepository televisionRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public QuerySearchIndexEpisodesHandler(
-            ISearchIndex searchIndex,
-            ITelevisionRepository televisionRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _searchIndex = searchIndex;
-            _televisionRepository = televisionRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<TelevisionEpisodeCardResultsViewModel> Handle(
-            QuerySearchIndexEpisodes request,
-            CancellationToken cancellationToken)
-        {
-            SearchResult searchResult = await _searchIndex.Search(
-                request.Query,
-                (request.PageNumber - 1) * request.PageSize,
-                request.PageSize);
-
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            List<TelevisionEpisodeCardViewModel> items = await _televisionRepository
-                .GetEpisodesForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby, true)).ToList());
-
-            return new TelevisionEpisodeCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
-        }
+        _searchIndex = searchIndex;
+        _televisionRepository = televisionRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<TelevisionEpisodeCardResultsViewModel> Handle(
+        QuerySearchIndexEpisodes request,
+        CancellationToken cancellationToken)
+    {
+        SearchResult searchResult = await _searchIndex.Search(
+            request.Query,
+            (request.PageNumber - 1) * request.PageSize,
+            request.PageSize);
+
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        List<TelevisionEpisodeCardViewModel> items = await _televisionRepository
+            .GetEpisodesForCards(searchResult.Items.Map(i => i.Id).ToList())
+            .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby, true)).ToList());
+
+        return new TelevisionEpisodeCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexMovies.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexMovies.cs
index 19b2a37c1..0e60cf7ef 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexMovies.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexMovies.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Application.MediaCards;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexMovies
-        (string Query, int PageNumber, int PageSize) : IRequest<MovieCardResultsViewModel>;
-}
+namespace ErsatzTV.Application.Search;
+
+public record QuerySearchIndexMovies
+    (string Query, int PageNumber, int PageSize) : IRequest<MovieCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexMoviesHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexMoviesHandler.cs
index 1823ac336..e0468afb2 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexMoviesHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexMoviesHandler.cs
@@ -1,54 +1,47 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class QuerySearchIndexMoviesHandler : IRequestHandler<QuerySearchIndexMovies, MovieCardResultsViewModel>
 {
-    public class QuerySearchIndexMoviesHandler : IRequestHandler<QuerySearchIndexMovies, MovieCardResultsViewModel>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMovieRepository _movieRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public QuerySearchIndexMoviesHandler(
+        ISearchIndex searchIndex,
+        IMovieRepository movieRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMovieRepository _movieRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public QuerySearchIndexMoviesHandler(
-            ISearchIndex searchIndex,
-            IMovieRepository movieRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _searchIndex = searchIndex;
-            _movieRepository = movieRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<MovieCardResultsViewModel> Handle(
-            QuerySearchIndexMovies request,
-            CancellationToken cancellationToken)
-        {
-            SearchResult searchResult = await _searchIndex.Search(
-                request.Query,
-                (request.PageNumber - 1) * request.PageSize,
-                request.PageSize);
-
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            List<MovieCardViewModel> items = await _movieRepository
-                .GetMoviesForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(m => ProjectToViewModel(m, maybeJellyfin, maybeEmby)).ToList());
-
-            return new MovieCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
-        }
+        _searchIndex = searchIndex;
+        _movieRepository = movieRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<MovieCardResultsViewModel> Handle(
+        QuerySearchIndexMovies request,
+        CancellationToken cancellationToken)
+    {
+        SearchResult searchResult = await _searchIndex.Search(
+            request.Query,
+            (request.PageNumber - 1) * request.PageSize,
+            request.PageSize);
+
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        List<MovieCardViewModel> items = await _movieRepository
+            .GetMoviesForCards(searchResult.Items.Map(i => i.Id).ToList())
+            .Map(list => list.Map(m => ProjectToViewModel(m, maybeJellyfin, maybeEmby)).ToList());
+
+        return new MovieCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideos.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideos.cs
index 8d7fd6df5..0b96bb2ab 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideos.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideos.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Application.MediaCards;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexMusicVideos
-        (string Query, int PageNumber, int PageSize) : IRequest<MusicVideoCardResultsViewModel>;
-}
+namespace ErsatzTV.Application.Search;
+
+public record QuerySearchIndexMusicVideos
+    (string Query, int PageNumber, int PageSize) : IRequest<MusicVideoCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideosHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideosHandler.cs
index 59739565c..4bfe5dfed 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideosHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexMusicVideosHandler.cs
@@ -1,44 +1,37 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class
+    QuerySearchIndexMusicVideosHandler : IRequestHandler<QuerySearchIndexMusicVideos, MusicVideoCardResultsViewModel
+    >
 {
-    public class
-        QuerySearchIndexMusicVideosHandler : IRequestHandler<QuerySearchIndexMusicVideos, MusicVideoCardResultsViewModel
-        >
+    private readonly IMusicVideoRepository _musicVideoRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public QuerySearchIndexMusicVideosHandler(ISearchIndex searchIndex, IMusicVideoRepository musicVideoRepository)
     {
-        private readonly IMusicVideoRepository _musicVideoRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public QuerySearchIndexMusicVideosHandler(ISearchIndex searchIndex, IMusicVideoRepository musicVideoRepository)
-        {
-            _searchIndex = searchIndex;
-            _musicVideoRepository = musicVideoRepository;
-        }
-
-        public async Task<MusicVideoCardResultsViewModel> Handle(
-            QuerySearchIndexMusicVideos request,
-            CancellationToken cancellationToken)
-        {
-            SearchResult searchResult = await _searchIndex.Search(
-                request.Query,
-                (request.PageNumber - 1) * request.PageSize,
-                request.PageSize);
-
-            List<MusicVideoCardViewModel> items = await _musicVideoRepository
-                .GetMusicVideosForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-
-            return new MusicVideoCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
-        }
+        _searchIndex = searchIndex;
+        _musicVideoRepository = musicVideoRepository;
     }
-}
+
+    public async Task<MusicVideoCardResultsViewModel> Handle(
+        QuerySearchIndexMusicVideos request,
+        CancellationToken cancellationToken)
+    {
+        SearchResult searchResult = await _searchIndex.Search(
+            request.Query,
+            (request.PageNumber - 1) * request.PageSize,
+            request.PageSize);
+
+        List<MusicVideoCardViewModel> items = await _musicVideoRepository
+            .GetMusicVideosForCards(searchResult.Items.Map(i => i.Id).ToList())
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+
+        return new MusicVideoCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideos.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideos.cs
index f1cae681e..5c3071051 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideos.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideos.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Application.MediaCards;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexOtherVideos
-        (string Query, int PageNumber, int PageSize) : IRequest<OtherVideoCardResultsViewModel>;
-}
+namespace ErsatzTV.Application.Search;
+
+public record QuerySearchIndexOtherVideos
+    (string Query, int PageNumber, int PageSize) : IRequest<OtherVideoCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs
index 109329ff8..c8ddcfd2f 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexOtherVideosHandler.cs
@@ -1,44 +1,37 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class
+    QuerySearchIndexOtherVideosHandler : IRequestHandler<QuerySearchIndexOtherVideos,
+        OtherVideoCardResultsViewModel>
 {
-    public class
-        QuerySearchIndexOtherVideosHandler : IRequestHandler<QuerySearchIndexOtherVideos,
-            OtherVideoCardResultsViewModel>
+    private readonly IOtherVideoRepository _otherVideoRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public QuerySearchIndexOtherVideosHandler(ISearchIndex searchIndex, IOtherVideoRepository otherVideoRepository)
     {
-        private readonly IOtherVideoRepository _otherVideoRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public QuerySearchIndexOtherVideosHandler(ISearchIndex searchIndex, IOtherVideoRepository otherVideoRepository)
-        {
-            _searchIndex = searchIndex;
-            _otherVideoRepository = otherVideoRepository;
-        }
-
-        public async Task<OtherVideoCardResultsViewModel> Handle(
-            QuerySearchIndexOtherVideos request,
-            CancellationToken cancellationToken)
-        {
-            SearchResult searchResult = await _searchIndex.Search(
-                request.Query,
-                (request.PageNumber - 1) * request.PageSize,
-                request.PageSize);
-
-            List<OtherVideoCardViewModel> items = await _otherVideoRepository
-                .GetOtherVideosForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-
-            return new OtherVideoCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
-        }
+        _searchIndex = searchIndex;
+        _otherVideoRepository = otherVideoRepository;
     }
-}
+
+    public async Task<OtherVideoCardResultsViewModel> Handle(
+        QuerySearchIndexOtherVideos request,
+        CancellationToken cancellationToken)
+    {
+        SearchResult searchResult = await _searchIndex.Search(
+            request.Query,
+            (request.PageNumber - 1) * request.PageSize,
+            request.PageSize);
+
+        List<OtherVideoCardViewModel> items = await _otherVideoRepository
+            .GetOtherVideosForCards(searchResult.Items.Map(i => i.Id).ToList())
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+
+        return new OtherVideoCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasons.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasons.cs
index 573607283..8b1494a30 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasons.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasons.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Application.MediaCards;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexSeasons
-        (string Query, int PageNumber, int PageSize) : IRequest<TelevisionSeasonCardResultsViewModel>;
-}
+namespace ErsatzTV.Application.Search;
+
+public record QuerySearchIndexSeasons
+    (string Query, int PageNumber, int PageSize) : IRequest<TelevisionSeasonCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasonsHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasonsHandler.cs
index 1f5530e50..dab5115db 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasonsHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSeasonsHandler.cs
@@ -1,55 +1,48 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class
+    QuerySearchIndexSeasonsHandler : IRequestHandler<QuerySearchIndexSeasons, TelevisionSeasonCardResultsViewModel>
 {
-    public class
-        QuerySearchIndexSeasonsHandler : IRequestHandler<QuerySearchIndexSeasons, TelevisionSeasonCardResultsViewModel>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public QuerySearchIndexSeasonsHandler(
+        ISearchIndex searchIndex,
+        ITelevisionRepository televisionRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public QuerySearchIndexSeasonsHandler(
-            ISearchIndex searchIndex,
-            ITelevisionRepository televisionRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _searchIndex = searchIndex;
-            _televisionRepository = televisionRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<TelevisionSeasonCardResultsViewModel> Handle(
-            QuerySearchIndexSeasons request,
-            CancellationToken cancellationToken)
-        {
-            SearchResult searchResult = await _searchIndex.Search(
-                request.Query,
-                (request.PageNumber - 1) * request.PageSize,
-                request.PageSize);
-
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            List<TelevisionSeasonCardViewModel> items = await _televisionRepository
-                .GetSeasonsForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
-
-            return new TelevisionSeasonCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
-        }
+        _searchIndex = searchIndex;
+        _televisionRepository = televisionRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<TelevisionSeasonCardResultsViewModel> Handle(
+        QuerySearchIndexSeasons request,
+        CancellationToken cancellationToken)
+    {
+        SearchResult searchResult = await _searchIndex.Search(
+            request.Query,
+            (request.PageNumber - 1) * request.PageSize,
+            request.PageSize);
+
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        List<TelevisionSeasonCardViewModel> items = await _televisionRepository
+            .GetSeasonsForCards(searchResult.Items.Map(i => i.Id).ToList())
+            .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
+
+        return new TelevisionSeasonCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexShows.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexShows.cs
index 156a1af48..a9e66cc47 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexShows.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexShows.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Application.MediaCards;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexShows
-        (string Query, int PageNumber, int PageSize) : IRequest<TelevisionShowCardResultsViewModel>;
-}
+namespace ErsatzTV.Application.Search;
+
+public record QuerySearchIndexShows
+    (string Query, int PageNumber, int PageSize) : IRequest<TelevisionShowCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexShowsHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexShowsHandler.cs
index c95d97f6a..4369fdf55 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexShowsHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexShowsHandler.cs
@@ -1,55 +1,48 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class
+    QuerySearchIndexShowsHandler : IRequestHandler<QuerySearchIndexShows, TelevisionShowCardResultsViewModel>
 {
-    public class
-        QuerySearchIndexShowsHandler : IRequestHandler<QuerySearchIndexShows, TelevisionShowCardResultsViewModel>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public QuerySearchIndexShowsHandler(
+        ISearchIndex searchIndex,
+        ITelevisionRepository televisionRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public QuerySearchIndexShowsHandler(
-            ISearchIndex searchIndex,
-            ITelevisionRepository televisionRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _searchIndex = searchIndex;
-            _televisionRepository = televisionRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<TelevisionShowCardResultsViewModel> Handle(
-            QuerySearchIndexShows request,
-            CancellationToken cancellationToken)
-        {
-            SearchResult searchResult = await _searchIndex.Search(
-                request.Query,
-                (request.PageNumber - 1) * request.PageSize,
-                request.PageSize);
-
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            List<TelevisionShowCardViewModel> items = await _televisionRepository
-                .GetShowsForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
-
-            return new TelevisionShowCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
-        }
+        _searchIndex = searchIndex;
+        _televisionRepository = televisionRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<TelevisionShowCardResultsViewModel> Handle(
+        QuerySearchIndexShows request,
+        CancellationToken cancellationToken)
+    {
+        SearchResult searchResult = await _searchIndex.Search(
+            request.Query,
+            (request.PageNumber - 1) * request.PageSize,
+            request.PageSize);
+
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        List<TelevisionShowCardViewModel> items = await _televisionRepository
+            .GetShowsForCards(searchResult.Items.Map(i => i.Id).ToList())
+            .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());
+
+        return new TelevisionShowCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSongs.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSongs.cs
index 713325acd..0331495b6 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSongs.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSongs.cs
@@ -1,8 +1,6 @@
 using ErsatzTV.Application.MediaCards;
-using MediatR;
 
-namespace ErsatzTV.Application.Search.Queries
-{
-    public record QuerySearchIndexSongs
-        (string Query, int PageNumber, int PageSize) : IRequest<SongCardResultsViewModel>;
-}
+namespace ErsatzTV.Application.Search;
+
+public record QuerySearchIndexSongs
+    (string Query, int PageNumber, int PageSize) : IRequest<SongCardResultsViewModel>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSongsHandler.cs b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSongsHandler.cs
index 2f4455384..50f4be1b5 100644
--- a/ErsatzTV.Application/Search/Queries/QuerySearchIndexSongsHandler.cs
+++ b/ErsatzTV.Application/Search/Queries/QuerySearchIndexSongsHandler.cs
@@ -1,44 +1,37 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
 
-namespace ErsatzTV.Application.Search.Queries
+namespace ErsatzTV.Application.Search;
+
+public class
+    QuerySearchIndexSongsHandler : IRequestHandler<QuerySearchIndexSongs,
+        SongCardResultsViewModel>
 {
-    public class
-        QuerySearchIndexSongsHandler : IRequestHandler<QuerySearchIndexSongs,
-            SongCardResultsViewModel>
+    private readonly ISongRepository _songRepository;
+    private readonly ISearchIndex _searchIndex;
+
+    public QuerySearchIndexSongsHandler(ISearchIndex searchIndex, ISongRepository songRepository)
     {
-        private readonly ISongRepository _songRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public QuerySearchIndexSongsHandler(ISearchIndex searchIndex, ISongRepository songRepository)
-        {
-            _searchIndex = searchIndex;
-            _songRepository = songRepository;
-        }
-
-        public async Task<SongCardResultsViewModel> Handle(
-            QuerySearchIndexSongs request,
-            CancellationToken cancellationToken)
-        {
-            SearchResult searchResult = await _searchIndex.Search(
-                request.Query,
-                (request.PageNumber - 1) * request.PageSize,
-                request.PageSize);
-
-            List<SongCardViewModel> items = await _songRepository
-                .GetSongsForCards(searchResult.Items.Map(i => i.Id).ToList())
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-
-            return new SongCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
-        }
+        _searchIndex = searchIndex;
+        _songRepository = songRepository;
     }
-}
+
+    public async Task<SongCardResultsViewModel> Handle(
+        QuerySearchIndexSongs request,
+        CancellationToken cancellationToken)
+    {
+        SearchResult searchResult = await _searchIndex.Search(
+            request.Query,
+            (request.PageNumber - 1) * request.PageSize,
+            request.PageSize);
+
+        List<SongCardViewModel> items = await _songRepository
+            .GetSongsForCards(searchResult.Items.Map(i => i.Id).ToList())
+            .Map(list => list.Map(ProjectToViewModel).ToList());
+
+        return new SongCardResultsViewModel(searchResult.TotalCount, items, searchResult.PageMap);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/SearchResultAllItemsViewModel.cs b/ErsatzTV.Application/Search/SearchResultAllItemsViewModel.cs
index 6d5f8a2f9..87b2e544c 100644
--- a/ErsatzTV.Application/Search/SearchResultAllItemsViewModel.cs
+++ b/ErsatzTV.Application/Search/SearchResultAllItemsViewModel.cs
@@ -1,14 +1,11 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.Search;
 
-namespace ErsatzTV.Application.Search
-{
-    public record SearchResultAllItemsViewModel(
-        List<int> MovieIds,
-        List<int> ShowIds,
-        List<int> SeasonIds,
-        List<int> EpisodeIds,
-        List<int> ArtistIds,
-        List<int> MusicVideoIds,
-        List<int> OtherVideoIds,
-        List<int> SongIds);
-}
+public record SearchResultAllItemsViewModel(
+    List<int> MovieIds,
+    List<int> ShowIds,
+    List<int> SeasonIds,
+    List<int> EpisodeIds,
+    List<int> ArtistIds,
+    List<int> MusicVideoIds,
+    List<int> OtherVideoIds,
+    List<int> SongIds);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Search/SearchResultViewModel.cs b/ErsatzTV.Application/Search/SearchResultViewModel.cs
index 59e487b9a..22ca86360 100644
--- a/ErsatzTV.Application/Search/SearchResultViewModel.cs
+++ b/ErsatzTV.Application/Search/SearchResultViewModel.cs
@@ -1,10 +1,7 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Application.Search;
 
-namespace ErsatzTV.Application.Search
+public class SearchResultViewModel<T>
 {
-    public class SearchResultViewModel<T>
-    {
-        public int TotalCount { get; set; }
-        public List<T> Items { get; set; }
-    }
-}
+    public int TotalCount { get; set; }
+    public List<T> Items { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Commands/StartFFmpegSession.cs b/ErsatzTV.Application/Streaming/Commands/StartFFmpegSession.cs
index 18bee0dc7..60892b0fe 100644
--- a/ErsatzTV.Application/Streaming/Commands/StartFFmpegSession.cs
+++ b/ErsatzTV.Application/Streaming/Commands/StartFFmpegSession.cs
@@ -1,9 +1,7 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Streaming.Commands
-{
-    public record StartFFmpegSession(string ChannelNumber, bool StartAtZero) :
-        MediatR.IRequest<Either<BaseError, Unit>>,
-        IFFmpegWorkerRequest;
-}
+namespace ErsatzTV.Application.Streaming;
+
+public record StartFFmpegSession(string ChannelNumber, bool StartAtZero) :
+    MediatR.IRequest<Either<BaseError, Unit>>,
+    IFFmpegWorkerRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs b/ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs
index a76db4b68..52bb5a4d3 100644
--- a/ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs
+++ b/ErsatzTV.Application/Streaming/Commands/StartFFmpegSessionHandler.cs
@@ -1,135 +1,128 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Streaming.Commands
+namespace ErsatzTV.Application.Streaming;
+
+public class StartFFmpegSessionHandler : MediatR.IRequestHandler<StartFFmpegSession, Either<BaseError, Unit>>
 {
-    public class StartFFmpegSessionHandler : MediatR.IRequestHandler<StartFFmpegSession, Either<BaseError, Unit>>
+    private readonly ILogger<StartFFmpegSessionHandler> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+    private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
+    private readonly ILocalFileSystem _localFileSystem;
+
+    public StartFFmpegSessionHandler(
+        ILocalFileSystem localFileSystem,
+        ILogger<StartFFmpegSessionHandler> logger,
+        IServiceScopeFactory serviceScopeFactory,
+        IFFmpegSegmenterService ffmpegSegmenterService,
+        IConfigElementRepository configElementRepository,
+        IHlsPlaylistFilter hlsPlaylistFilter)
     {
-        private readonly ILogger<StartFFmpegSessionHandler> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
-        private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
-        private readonly ILocalFileSystem _localFileSystem;
+        _localFileSystem = localFileSystem;
+        _logger = logger;
+        _serviceScopeFactory = serviceScopeFactory;
+        _ffmpegSegmenterService = ffmpegSegmenterService;
+        _configElementRepository = configElementRepository;
+        _hlsPlaylistFilter = hlsPlaylistFilter;
+    }
 
-        public StartFFmpegSessionHandler(
-            ILocalFileSystem localFileSystem,
-            ILogger<StartFFmpegSessionHandler> logger,
-            IServiceScopeFactory serviceScopeFactory,
-            IFFmpegSegmenterService ffmpegSegmenterService,
-            IConfigElementRepository configElementRepository,
-            IHlsPlaylistFilter hlsPlaylistFilter)
-        {
-            _localFileSystem = localFileSystem;
-            _logger = logger;
-            _serviceScopeFactory = serviceScopeFactory;
-            _ffmpegSegmenterService = ffmpegSegmenterService;
-            _configElementRepository = configElementRepository;
-            _hlsPlaylistFilter = hlsPlaylistFilter;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(StartFFmpegSession request, CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(_ => StartProcess(request))
-                // this weirdness is needed to maintain the error type (.ToEitherAsync() just gives BaseError)
+    public Task<Either<BaseError, Unit>> Handle(StartFFmpegSession request, CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(_ => StartProcess(request))
+            // this weirdness is needed to maintain the error type (.ToEitherAsync() just gives BaseError)
 #pragma warning disable VSTHRD103
-                .Bind(v => v.ToEither().MapLeft(seq => seq.Head()).MapAsync<BaseError, Task<Unit>, Unit>(identity));
+            .Bind(v => v.ToEither().MapLeft(seq => seq.Head()).MapAsync<BaseError, Task<Unit>, Unit>(identity));
 #pragma warning restore VSTHRD103
 
-        private async Task<Unit> StartProcess(StartFFmpegSession request)
+    private async Task<Unit> StartProcess(StartFFmpegSession request)
+    {
+        TimeSpan idleTimeout = await _configElementRepository
+            .GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout)
+            .Map(maybeTimeout => maybeTimeout.Match(i => TimeSpan.FromSeconds(i), () => TimeSpan.FromMinutes(1)));
+
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        HlsSessionWorker worker = scope.ServiceProvider.GetRequiredService<HlsSessionWorker>();
+        _ffmpegSegmenterService.SessionWorkers.AddOrUpdate(request.ChannelNumber, _ => worker, (_, _) => worker);
+
+        // fire and forget worker
+        _ = worker.Run(request.ChannelNumber, idleTimeout)
+            .ContinueWith(
+                _ => _ffmpegSegmenterService.SessionWorkers.TryRemove(
+                    request.ChannelNumber,
+                    out IHlsSessionWorker _),
+                TaskScheduler.Default);
+
+        string playlistFileName = Path.Combine(
+            FileSystemLayout.TranscodeFolder,
+            request.ChannelNumber,
+            "live.m3u8");
+
+        IConfigElementRepository repo = scope.ServiceProvider.GetRequiredService<IConfigElementRepository>();
+        int initialSegmentCount = await repo.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount)
+            .Map(maybeCount => maybeCount.Match(identity, () => 1));
+
+        await WaitForPlaylistSegments(playlistFileName, initialSegmentCount, worker);
+
+        return Unit.Default;
+    }
+
+    private async Task WaitForPlaylistSegments(string playlistFileName, int initialSegmentCount, IHlsSessionWorker worker)
+    {
+        while (!File.Exists(playlistFileName))
         {
-            TimeSpan idleTimeout = await _configElementRepository
-                .GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout)
-                .Map(maybeTimeout => maybeTimeout.Match(i => TimeSpan.FromSeconds(i), () => TimeSpan.FromMinutes(1)));
-
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            HlsSessionWorker worker = scope.ServiceProvider.GetRequiredService<HlsSessionWorker>();
-            _ffmpegSegmenterService.SessionWorkers.AddOrUpdate(request.ChannelNumber, _ => worker, (_, _) => worker);
-
-            // fire and forget worker
-            _ = worker.Run(request.ChannelNumber, idleTimeout)
-                .ContinueWith(
-                    _ => _ffmpegSegmenterService.SessionWorkers.TryRemove(
-                        request.ChannelNumber,
-                        out IHlsSessionWorker _),
-                    TaskScheduler.Default);
-
-            string playlistFileName = Path.Combine(
-                FileSystemLayout.TranscodeFolder,
-                request.ChannelNumber,
-                "live.m3u8");
-
-            IConfigElementRepository repo = scope.ServiceProvider.GetRequiredService<IConfigElementRepository>();
-            int initialSegmentCount = await repo.GetValue<int>(ConfigElementKey.FFmpegInitialSegmentCount)
-                .Map(maybeCount => maybeCount.Match(identity, () => 1));
-
-            await WaitForPlaylistSegments(playlistFileName, initialSegmentCount, worker);
-
-            return Unit.Default;
+            await Task.Delay(TimeSpan.FromMilliseconds(100));
         }
 
-        private async Task WaitForPlaylistSegments(string playlistFileName, int initialSegmentCount, IHlsSessionWorker worker)
+        var segmentCount = 0;
+        while (segmentCount < initialSegmentCount)
         {
-            while (!File.Exists(playlistFileName))
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(100));
-            }
-
-            var segmentCount = 0;
-            while (segmentCount < initialSegmentCount)
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(200));
+            await Task.Delay(TimeSpan.FromMilliseconds(200));
                 
-                DateTimeOffset now = DateTimeOffset.Now.AddSeconds(-30);
-                string[] input = await File.ReadAllLinesAsync(playlistFileName);
-                TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(worker.PlaylistStart, now, input);
-                segmentCount = result.SegmentCount;
-            }
-        }
-
-        private Task<Validation<BaseError, Unit>> Validate(StartFFmpegSession request) =>
-            SessionMustBeInactive(request)
-                .BindT(_ => FolderMustBeEmpty(request));
-
-        private Task<Validation<BaseError, Unit>> SessionMustBeInactive(StartFFmpegSession request)
-        {
-            var result = Optional(_ffmpegSegmenterService.SessionWorkers.TryAdd(request.ChannelNumber, null))
-                .Where(success => success)
-                .Map(_ => Unit.Default)
-                .ToValidation<BaseError>(new ChannelSessionAlreadyActive());
-
-            if (result.IsFail && _ffmpegSegmenterService.SessionWorkers.TryGetValue(
-                request.ChannelNumber,
-                out IHlsSessionWorker worker))
-            {
-                worker?.Touch();
-            }
-
-            return result.AsTask();
-        }
-
-        private Task<Validation<BaseError, Unit>> FolderMustBeEmpty(StartFFmpegSession request)
-        {
-            string folder = Path.Combine(FileSystemLayout.TranscodeFolder, request.ChannelNumber);
-            _logger.LogDebug("Preparing transcode folder {Folder}", folder);
-
-            _localFileSystem.EnsureFolderExists(folder);
-            _localFileSystem.EmptyFolder(folder);
-
-            return Task.FromResult<Validation<BaseError, Unit>>(Unit.Default);
+            DateTimeOffset now = DateTimeOffset.Now.AddSeconds(-30);
+            string[] input = await File.ReadAllLinesAsync(playlistFileName);
+            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(worker.PlaylistStart, now, input);
+            segmentCount = result.SegmentCount;
         }
     }
-}
+
+    private Task<Validation<BaseError, Unit>> Validate(StartFFmpegSession request) =>
+        SessionMustBeInactive(request)
+            .BindT(_ => FolderMustBeEmpty(request));
+
+    private Task<Validation<BaseError, Unit>> SessionMustBeInactive(StartFFmpegSession request)
+    {
+        var result = Optional(_ffmpegSegmenterService.SessionWorkers.TryAdd(request.ChannelNumber, null))
+            .Where(success => success)
+            .Map(_ => Unit.Default)
+            .ToValidation<BaseError>(new ChannelSessionAlreadyActive());
+
+        if (result.IsFail && _ffmpegSegmenterService.SessionWorkers.TryGetValue(
+                request.ChannelNumber,
+                out IHlsSessionWorker worker))
+        {
+            worker?.Touch();
+        }
+
+        return result.AsTask();
+    }
+
+    private Task<Validation<BaseError, Unit>> FolderMustBeEmpty(StartFFmpegSession request)
+    {
+        string folder = Path.Combine(FileSystemLayout.TranscodeFolder, request.ChannelNumber);
+        _logger.LogDebug("Preparing transcode folder {Folder}", folder);
+
+        _localFileSystem.EnsureFolderExists(folder);
+        _localFileSystem.EmptyFolder(folder);
+
+        return Task.FromResult<Validation<BaseError, Unit>>(Unit.Default);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Commands/TouchFFmpegSession.cs b/ErsatzTV.Application/Streaming/Commands/TouchFFmpegSession.cs
index 34d0d5a42..02888f5ee 100644
--- a/ErsatzTV.Application/Streaming/Commands/TouchFFmpegSession.cs
+++ b/ErsatzTV.Application/Streaming/Commands/TouchFFmpegSession.cs
@@ -1,9 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Streaming.Commands
-{
-    public record TouchFFmpegSession(string Path) : IRequest<Either<BaseError, Unit>>, IFFmpegWorkerRequest;
-}
+namespace ErsatzTV.Application.Streaming;
+
+public record TouchFFmpegSession(string Path) : IRequest<Either<BaseError, Unit>>, IFFmpegWorkerRequest;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/HlsSessionWorker.cs b/ErsatzTV.Application/Streaming/HlsSessionWorker.cs
index dce27c778..a2f7b97c1 100644
--- a/ErsatzTV.Application/Streaming/HlsSessionWorker.cs
+++ b/ErsatzTV.Application/Streaming/HlsSessionWorker.cs
@@ -1,303 +1,293 @@
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using System.Timers;
-using ErsatzTV.Application.Channels.Queries;
-using ErsatzTV.Application.Streaming.Queries;
+using ErsatzTV.Application.Channels;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Timer = System.Timers.Timer;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Streaming
+namespace ErsatzTV.Application.Streaming;
+
+public class HlsSessionWorker : IHlsSessionWorker
 {
-    public class HlsSessionWorker : IHlsSessionWorker
+    private static int _workAheadCount;
+    private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+    private readonly ILogger<HlsSessionWorker> _logger;
+    private DateTimeOffset _lastAccess;
+    private DateTimeOffset _transcodedUntil;
+    private Timer _timer;
+    private readonly object _sync = new();
+    private DateTimeOffset _playlistStart;
+    private Option<int> _targetFramerate;
+
+    public HlsSessionWorker(IHlsPlaylistFilter hlsPlaylistFilter, IServiceScopeFactory serviceScopeFactory, ILogger<HlsSessionWorker> logger)
     {
-        private static int _workAheadCount;
-        private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
-        private readonly ILogger<HlsSessionWorker> _logger;
-        private DateTimeOffset _lastAccess;
-        private DateTimeOffset _transcodedUntil;
-        private Timer _timer;
-        private readonly object _sync = new();
-        private DateTimeOffset _playlistStart;
-        private Option<int> _targetFramerate;
+        _hlsPlaylistFilter = hlsPlaylistFilter;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
+    }
 
-        public HlsSessionWorker(IHlsPlaylistFilter hlsPlaylistFilter, IServiceScopeFactory serviceScopeFactory, ILogger<HlsSessionWorker> logger)
+    public DateTimeOffset PlaylistStart => _playlistStart;
+
+    public void Touch()
+    {
+        lock (_sync)
         {
-            _hlsPlaylistFilter = hlsPlaylistFilter;
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
+            _lastAccess = DateTimeOffset.Now;
+
+            _timer?.Stop();
+            _timer?.Start();
         }
+    }
 
-        public DateTimeOffset PlaylistStart => _playlistStart;
+    public async Task Run(string channelNumber, TimeSpan idleTimeout)
+    {
+        var cts = new CancellationTokenSource();
+        void Cancel(object o, ElapsedEventArgs e) => cts.Cancel();
 
-        public void Touch()
+        try
         {
             lock (_sync)
             {
-                _lastAccess = DateTimeOffset.Now;
-
-                _timer?.Stop();
-                _timer?.Start();
+                _timer = new Timer(idleTimeout.TotalMilliseconds) { AutoReset = false };
+                _timer.Elapsed += Cancel;
             }
-        }
 
-        public async Task Run(string channelNumber, TimeSpan idleTimeout)
-        {
-            var cts = new CancellationTokenSource();
-            void Cancel(object o, ElapsedEventArgs e) => cts.Cancel();
+            CancellationToken cancellationToken = cts.Token;
 
-            try
-            {
-                lock (_sync)
-                {
-                    _timer = new Timer(idleTimeout.TotalMilliseconds) { AutoReset = false };
-                    _timer.Elapsed += Cancel;
-                }
-
-                CancellationToken cancellationToken = cts.Token;
-
-                _logger.LogInformation("Starting HLS session for channel {Channel}", channelNumber);
+            _logger.LogInformation("Starting HLS session for channel {Channel}", channelNumber);
                 
-                using IServiceScope scope = _serviceScopeFactory.CreateScope();
-                IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+            using IServiceScope scope = _serviceScopeFactory.CreateScope();
+            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
 
-                _targetFramerate = await mediator.Send(
-                    new GetChannelFramerate(channelNumber),
-                    cancellationToken);
+            _targetFramerate = await mediator.Send(
+                new GetChannelFramerate(channelNumber),
+                cancellationToken);
 
-                Touch();
-                _transcodedUntil = DateTimeOffset.Now;
-                _playlistStart = _transcodedUntil;
+            Touch();
+            _transcodedUntil = DateTimeOffset.Now;
+            _playlistStart = _transcodedUntil;
 
-                bool initialWorkAhead = Volatile.Read(ref _workAheadCount) < await GetWorkAheadLimit();
-                if (!await Transcode(channelNumber, true, !initialWorkAhead, cancellationToken))
+            bool initialWorkAhead = Volatile.Read(ref _workAheadCount) < await GetWorkAheadLimit();
+            if (!await Transcode(channelNumber, true, !initialWorkAhead, cancellationToken))
+            {
+                return;
+            }
+
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                if (DateTimeOffset.Now - _lastAccess > idleTimeout)
                 {
+                    _logger.LogInformation("Stopping idle HLS session for channel {Channel}", channelNumber);
                     return;
                 }
 
-                while (!cancellationToken.IsCancellationRequested)
+                var transcodedBuffer = TimeSpan.FromSeconds(
+                    Math.Max(0, _transcodedUntil.Subtract(DateTimeOffset.Now).TotalSeconds));
+                if (transcodedBuffer <= TimeSpan.FromMinutes(1))
                 {
-                    if (DateTimeOffset.Now - _lastAccess > idleTimeout)
+                    // only use realtime encoding when we're at least 30 seconds ahead
+                    bool realtime = transcodedBuffer >= TimeSpan.FromSeconds(30);
+                    bool subsequentWorkAhead =
+                        !realtime && Volatile.Read(ref _workAheadCount) < await GetWorkAheadLimit();
+                    if (!await Transcode(channelNumber, false, !subsequentWorkAhead, cancellationToken))
                     {
-                        _logger.LogInformation("Stopping idle HLS session for channel {Channel}", channelNumber);
                         return;
                     }
-
-                    var transcodedBuffer = TimeSpan.FromSeconds(
-                        Math.Max(0, _transcodedUntil.Subtract(DateTimeOffset.Now).TotalSeconds));
-                    if (transcodedBuffer <= TimeSpan.FromMinutes(1))
-                    {
-                        // only use realtime encoding when we're at least 30 seconds ahead
-                        bool realtime = transcodedBuffer >= TimeSpan.FromSeconds(30);
-                        bool subsequentWorkAhead =
-                            !realtime && Volatile.Read(ref _workAheadCount) < await GetWorkAheadLimit();
-                        if (!await Transcode(channelNumber, false, !subsequentWorkAhead, cancellationToken))
-                        {
-                            return;
-                        }
-                    }
-                    else
-                    {
-                        await TrimAndDelete(channelNumber, cancellationToken);
-                        await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
-                    }
-                }
-            }
-            finally
-            {
-                lock (_sync)
-                {
-                    _timer.Elapsed -= Cancel;
-                }
-            }
-        }
-
-        private async Task<bool> Transcode(
-            string channelNumber,
-            bool firstProcess,
-            bool realtime,
-            CancellationToken cancellationToken)
-        {
-            try
-            {
-                if (!realtime)
-                {
-                    Interlocked.Increment(ref _workAheadCount);
-                    _logger.LogInformation("HLS segmenter will work ahead for channel {Channel}", channelNumber);
                 }
                 else
                 {
-                    _logger.LogInformation(
-                        "HLS segmenter will NOT work ahead for channel {Channel}",
-                        channelNumber);
+                    await TrimAndDelete(channelNumber, cancellationToken);
+                    await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
                 }
+            }
+        }
+        finally
+        {
+            lock (_sync)
+            {
+                _timer.Elapsed -= Cancel;
+            }
+        }
+    }
 
-                using IServiceScope scope = _serviceScopeFactory.CreateScope();
-                IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+    private async Task<bool> Transcode(
+        string channelNumber,
+        bool firstProcess,
+        bool realtime,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (!realtime)
+            {
+                Interlocked.Increment(ref _workAheadCount);
+                _logger.LogInformation("HLS segmenter will work ahead for channel {Channel}", channelNumber);
+            }
+            else
+            {
+                _logger.LogInformation(
+                    "HLS segmenter will NOT work ahead for channel {Channel}",
+                    channelNumber);
+            }
 
-                long ptsOffset = await GetPtsOffset(mediator, channelNumber, cancellationToken);
-                // _logger.LogInformation("PTS offset: {PtsOffset}", ptsOffset);
+            using IServiceScope scope = _serviceScopeFactory.CreateScope();
+            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
 
-                var request = new GetPlayoutItemProcessByChannelNumber(
+            long ptsOffset = await GetPtsOffset(mediator, channelNumber, cancellationToken);
+            // _logger.LogInformation("PTS offset: {PtsOffset}", ptsOffset);
+
+            var request = new GetPlayoutItemProcessByChannelNumber(
+                channelNumber,
+                "segmenter",
+                firstProcess ? DateTimeOffset.Now : _transcodedUntil.AddSeconds(1),
+                !firstProcess,
+                realtime,
+                ptsOffset,
+                _targetFramerate);
+
+            // _logger.LogInformation("Request {@Request}", request);
+
+            Either<BaseError, PlayoutItemProcessModel> result = await mediator.Send(request, cancellationToken);
+
+            // _logger.LogInformation("Result {Result}", result.ToString());
+
+            foreach (BaseError error in result.LeftAsEnumerable())
+            {
+                _logger.LogWarning(
+                    "Failed to create process for HLS session on channel {Channel}: {Error}",
                     channelNumber,
-                    "segmenter",
-                    firstProcess ? DateTimeOffset.Now : _transcodedUntil.AddSeconds(1),
-                    !firstProcess,
-                    realtime,
-                    ptsOffset,
-                    _targetFramerate);
+                    error.ToString());
 
-                // _logger.LogInformation("Request {@Request}", request);
+                return false;
+            }
 
-                Either<BaseError, PlayoutItemProcessModel> result = await mediator.Send(request, cancellationToken);
+            foreach (PlayoutItemProcessModel processModel in result.RightAsEnumerable())
+            {
+                await TrimAndDelete(channelNumber, cancellationToken);
 
-                // _logger.LogInformation("Result {Result}", result.ToString());
+                Process process = processModel.Process;
 
-                foreach (BaseError error in result.LeftAsEnumerable())
+                _logger.LogInformation(
+                    "ffmpeg hls arguments {FFmpegArguments}",
+                    string.Join(" ", process.StartInfo.ArgumentList));
+
+                process.Start();
+                try
                 {
-                    _logger.LogWarning(
-                        "Failed to create process for HLS session on channel {Channel}: {Error}",
-                        channelNumber,
-                        error.ToString());
+                    await process.WaitForExitAsync(cancellationToken);
+                    process.WaitForExit();
+                }
+                catch (TaskCanceledException)
+                {
+                    _logger.LogInformation("Terminating HLS process for channel {Channel}", channelNumber);
+                    process.Kill();
+                    process.WaitForExit();
 
                     return false;
                 }
 
-                foreach (PlayoutItemProcessModel processModel in result.RightAsEnumerable())
-                {
-                    await TrimAndDelete(channelNumber, cancellationToken);
+                _logger.LogInformation("HLS process has completed for channel {Channel}", channelNumber);
 
-                    Process process = processModel.Process;
-
-                    _logger.LogInformation(
-                        "ffmpeg hls arguments {FFmpegArguments}",
-                        string.Join(" ", process.StartInfo.ArgumentList));
-
-                    process.Start();
-                    try
-                    {
-                        await process.WaitForExitAsync(cancellationToken);
-                        process.WaitForExit();
-                    }
-                    catch (TaskCanceledException)
-                    {
-                        _logger.LogInformation("Terminating HLS process for channel {Channel}", channelNumber);
-                        process.Kill();
-                        process.WaitForExit();
-
-                        return false;
-                    }
-
-                    _logger.LogInformation("HLS process has completed for channel {Channel}", channelNumber);
-
-                    _transcodedUntil = processModel.Until;
-                }
+                _transcodedUntil = processModel.Until;
             }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error transcoding channel {Channel}", channelNumber);
-                return false;
-            }
-            finally
-            {
-                Interlocked.Decrement(ref _workAheadCount);
-            }
-
-            return true;
         }
-
-        private async Task TrimAndDelete(string channelNumber, CancellationToken cancellationToken)
+        catch (Exception ex)
         {
-            string playlistFileName = Path.Combine(
-                FileSystemLayout.TranscodeFolder,
-                channelNumber,
-                "live.m3u8");
-
-            if (File.Exists(playlistFileName))
-            {
-                // trim playlist and insert discontinuity before appending with new ffmpeg process
-                string[] lines = await File.ReadAllLinesAsync(playlistFileName, cancellationToken);
-                TrimPlaylistResult trimResult = _hlsPlaylistFilter.TrimPlaylistWithDiscontinuity(
-                    _playlistStart,
-                    DateTimeOffset.Now.AddMinutes(-1),
-                    lines);
-                await File.WriteAllTextAsync(playlistFileName, trimResult.Playlist, cancellationToken);
-
-                // delete old segments
-                var allSegments = Directory.GetFiles(
-                        Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber),
-                        "live*.ts")
-                    .Map(
-                        file =>
-                        {
-                            string fileName = Path.GetFileName(file);
-                            var sequenceNumber = int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]);
-                            return new Segment(file, sequenceNumber);
-                        })
-                    .ToList();
-
-                var toDelete = allSegments.Filter(s => s.SequenceNumber < trimResult.Sequence).ToList();
-                // if (toDelete.Count > 0)
-                // {
-                // _logger.LogInformation(
-                //     "Deleting HLS segments {Min} to {Max} (less than {StartSequence})",
-                //     toDelete.Map(s => s.SequenceNumber).Min(),
-                //     toDelete.Map(s => s.SequenceNumber).Max(),
-                //     trimResult.Sequence);
-                // }
-
-                foreach (Segment segment in toDelete)
-                {
-                    File.Delete(segment.File);
-                }
-
-                _playlistStart = trimResult.PlaylistStart;
-            }
+            _logger.LogError(ex, "Error transcoding channel {Channel}", channelNumber);
+            return false;
         }
-
-        private async Task<long> GetPtsOffset(IMediator mediator, string channelNumber, CancellationToken cancellationToken)
+        finally
         {
-            var directory = new DirectoryInfo(Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber));
-            Option<FileInfo> lastSegment =
-                Optional(directory.GetFiles("*.ts").OrderByDescending(f => f.Name).FirstOrDefault());
-
-            long result = 0;
-            foreach (FileInfo segment in lastSegment)
-            {
-                Either<BaseError, PtsAndDuration> queryResult = await mediator.Send(
-                    new GetLastPtsDuration(segment.FullName),
-                    cancellationToken);
-
-                foreach (PtsAndDuration ptsAndDuration in queryResult.RightToSeq())
-                {
-                    result = ptsAndDuration.Pts + ptsAndDuration.Duration;
-                }
-            }
-
-            return result;
+            Interlocked.Decrement(ref _workAheadCount);
         }
 
-        private async Task<int> GetWorkAheadLimit()
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IConfigElementRepository repo = scope.ServiceProvider.GetRequiredService<IConfigElementRepository>();
-            return await repo.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters)
-                .Map(maybeCount => maybeCount.Match(identity, () => 1));
-        }
-
-        private record Segment(string File, int SequenceNumber);
+        return true;
     }
-}
+
+    private async Task TrimAndDelete(string channelNumber, CancellationToken cancellationToken)
+    {
+        string playlistFileName = Path.Combine(
+            FileSystemLayout.TranscodeFolder,
+            channelNumber,
+            "live.m3u8");
+
+        if (File.Exists(playlistFileName))
+        {
+            // trim playlist and insert discontinuity before appending with new ffmpeg process
+            string[] lines = await File.ReadAllLinesAsync(playlistFileName, cancellationToken);
+            TrimPlaylistResult trimResult = _hlsPlaylistFilter.TrimPlaylistWithDiscontinuity(
+                _playlistStart,
+                DateTimeOffset.Now.AddMinutes(-1),
+                lines);
+            await File.WriteAllTextAsync(playlistFileName, trimResult.Playlist, cancellationToken);
+
+            // delete old segments
+            var allSegments = Directory.GetFiles(
+                    Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber),
+                    "live*.ts")
+                .Map(
+                    file =>
+                    {
+                        string fileName = Path.GetFileName(file);
+                        var sequenceNumber = int.Parse(fileName.Replace("live", string.Empty).Split('.')[0]);
+                        return new Segment(file, sequenceNumber);
+                    })
+                .ToList();
+
+            var toDelete = allSegments.Filter(s => s.SequenceNumber < trimResult.Sequence).ToList();
+            // if (toDelete.Count > 0)
+            // {
+            // _logger.LogInformation(
+            //     "Deleting HLS segments {Min} to {Max} (less than {StartSequence})",
+            //     toDelete.Map(s => s.SequenceNumber).Min(),
+            //     toDelete.Map(s => s.SequenceNumber).Max(),
+            //     trimResult.Sequence);
+            // }
+
+            foreach (Segment segment in toDelete)
+            {
+                File.Delete(segment.File);
+            }
+
+            _playlistStart = trimResult.PlaylistStart;
+        }
+    }
+
+    private async Task<long> GetPtsOffset(IMediator mediator, string channelNumber, CancellationToken cancellationToken)
+    {
+        var directory = new DirectoryInfo(Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber));
+        Option<FileInfo> lastSegment =
+            Optional(directory.GetFiles("*.ts").OrderByDescending(f => f.Name).FirstOrDefault());
+
+        long result = 0;
+        foreach (FileInfo segment in lastSegment)
+        {
+            Either<BaseError, PtsAndDuration> queryResult = await mediator.Send(
+                new GetLastPtsDuration(segment.FullName),
+                cancellationToken);
+
+            foreach (PtsAndDuration ptsAndDuration in queryResult.RightToSeq())
+            {
+                result = ptsAndDuration.Pts + ptsAndDuration.Duration;
+            }
+        }
+
+        return result;
+    }
+
+    private async Task<int> GetWorkAheadLimit()
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IConfigElementRepository repo = scope.ServiceProvider.GetRequiredService<IConfigElementRepository>();
+        return await repo.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters)
+            .Map(maybeCount => maybeCount.Match(identity, () => 1));
+    }
+
+    private record Segment(string File, int SequenceNumber);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/PlayoutItemProcessModel.cs b/ErsatzTV.Application/Streaming/PlayoutItemProcessModel.cs
index 281790e0a..91e113282 100644
--- a/ErsatzTV.Application/Streaming/PlayoutItemProcessModel.cs
+++ b/ErsatzTV.Application/Streaming/PlayoutItemProcessModel.cs
@@ -1,7 +1,5 @@
-using System;
-using System.Diagnostics;
+using System.Diagnostics;
 
-namespace ErsatzTV.Application.Streaming
-{
-    public record PlayoutItemProcessModel(Process Process, DateTimeOffset Until);
-}
+namespace ErsatzTV.Application.Streaming;
+
+public record PlayoutItemProcessModel(Process Process, DateTimeOffset Until);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs b/ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs
index 7ba2d96a0..d990cf9c6 100644
--- a/ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/FFmpegProcessHandler.cs
@@ -1,73 +1,65 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Streaming.Queries
+namespace ErsatzTV.Application.Streaming;
+
+public abstract class FFmpegProcessHandler<T> : IRequestHandler<T, Either<BaseError, PlayoutItemProcessModel>>
+    where T : FFmpegProcessRequest
 {
-    public abstract class FFmpegProcessHandler<T> : IRequestHandler<T, Either<BaseError, PlayoutItemProcessModel>>
-        where T : FFmpegProcessRequest
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    protected FFmpegProcessHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, PlayoutItemProcessModel>> Handle(T request, CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        protected FFmpegProcessHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, PlayoutItemProcessModel>> Handle(T request, CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            Validation<BaseError, Tuple<Channel, string>> validation = await Validate(dbContext, request);
-            return await validation.Match(
-                tuple => GetProcess(dbContext, request, tuple.Item1, tuple.Item2),
-                error => Task.FromResult<Either<BaseError, PlayoutItemProcessModel>>(error.Join()));
-        }
-
-        protected abstract Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
-            TvContext dbContext,
-            T request,
-            Channel channel,
-            string ffmpegPath);
-
-        private static async Task<Validation<BaseError, Tuple<Channel, string>>> Validate(
-            TvContext dbContext,
-            T request) =>
-            (await ChannelMustExist(dbContext, request), await FFmpegPathMustExist(dbContext))
-            .Apply((channel, ffmpegPath) => Tuple(channel, ffmpegPath));
-
-        private static Task<Validation<BaseError, Channel>> ChannelMustExist(TvContext dbContext, T request) =>
-            dbContext.Channels
-                .Include(c => c.FFmpegProfile)
-                .ThenInclude(p => p.Resolution)
-                .Include(c => c.Artwork)
-                .Include(c => c.Watermark)
-                .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber)
-                .MapT(
-                    channel =>
-                    {
-                        channel.StreamingMode = request.Mode.ToLowerInvariant() switch
-                        {
-                            "hls-direct" => StreamingMode.HttpLiveStreamingDirect,
-                            "segmenter" => StreamingMode.HttpLiveStreamingSegmenter,
-                            "ts" => StreamingMode.TransportStreamHybrid,
-                            "ts-legacy" => StreamingMode.TransportStream,
-                            _ => channel.StreamingMode
-                        };
-
-                        return channel;
-                    })
-                .Map(o => o.ToValidation<BaseError>($"Channel number {request.ChannelNumber} does not exist."));
-
-        private static Task<Validation<BaseError, string>> FFmpegPathMustExist(TvContext dbContext) =>
-            dbContext.ConfigElements.GetValue<string>(ConfigElementKey.FFmpegPath)
-                .FilterT(File.Exists)
-                .Map(maybePath => maybePath.ToValidation<BaseError>("FFmpeg path does not exist on filesystem"));
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, Tuple<Channel, string>> validation = await Validate(dbContext, request);
+        return await validation.Match(
+            tuple => GetProcess(dbContext, request, tuple.Item1, tuple.Item2),
+            error => Task.FromResult<Either<BaseError, PlayoutItemProcessModel>>(error.Join()));
     }
-}
+
+    protected abstract Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
+        TvContext dbContext,
+        T request,
+        Channel channel,
+        string ffmpegPath);
+
+    private static async Task<Validation<BaseError, Tuple<Channel, string>>> Validate(
+        TvContext dbContext,
+        T request) =>
+        (await ChannelMustExist(dbContext, request), await FFmpegPathMustExist(dbContext))
+        .Apply((channel, ffmpegPath) => Tuple(channel, ffmpegPath));
+
+    private static Task<Validation<BaseError, Channel>> ChannelMustExist(TvContext dbContext, T request) =>
+        dbContext.Channels
+            .Include(c => c.FFmpegProfile)
+            .ThenInclude(p => p.Resolution)
+            .Include(c => c.Artwork)
+            .Include(c => c.Watermark)
+            .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber)
+            .MapT(
+                channel =>
+                {
+                    channel.StreamingMode = request.Mode.ToLowerInvariant() switch
+                    {
+                        "hls-direct" => StreamingMode.HttpLiveStreamingDirect,
+                        "segmenter" => StreamingMode.HttpLiveStreamingSegmenter,
+                        "ts" => StreamingMode.TransportStreamHybrid,
+                        "ts-legacy" => StreamingMode.TransportStream,
+                        _ => channel.StreamingMode
+                    };
+
+                    return channel;
+                })
+            .Map(o => o.ToValidation<BaseError>($"Channel number {request.ChannelNumber} does not exist."));
+
+    private static Task<Validation<BaseError, string>> FFmpegPathMustExist(TvContext dbContext) =>
+        dbContext.ConfigElements.GetValue<string>(ConfigElementKey.FFmpegPath)
+            .FilterT(File.Exists)
+            .Map(maybePath => maybePath.ToValidation<BaseError>("FFmpeg path does not exist on filesystem"));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs b/ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs
index 635a1723f..6ec1dc363 100644
--- a/ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs
+++ b/ErsatzTV.Application/Streaming/Queries/FFmpegProcessRequest.cs
@@ -1,16 +1,12 @@
-using System;
-using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Core;
 
-namespace ErsatzTV.Application.Streaming.Queries
-{
-    public record FFmpegProcessRequest
-    (
-        string ChannelNumber,
-        string Mode,
-        DateTimeOffset Now,
-        bool StartAtZero,
-        bool HlsRealtime,
-        long PtsOffset) : IRequest<Either<BaseError, PlayoutItemProcessModel>>;
-}
+namespace ErsatzTV.Application.Streaming;
+
+public record FFmpegProcessRequest
+(
+    string ChannelNumber,
+    string Mode,
+    DateTimeOffset Now,
+    bool StartAtZero,
+    bool HlsRealtime,
+    long PtsOffset) : IRequest<Either<BaseError, PlayoutItemProcessModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumber.cs b/ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumber.cs
index 352a429ad..e2944ca24 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumber.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumber.cs
@@ -1,10 +1,7 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.FFmpeg;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Streaming.Queries
-{
-    public record GetConcatPlaylistByChannelNumber
-        (string Scheme, string Host, string ChannelNumber) : IRequest<Either<BaseError, ConcatPlaylist>>;
-}
+namespace ErsatzTV.Application.Streaming;
+
+public record GetConcatPlaylistByChannelNumber
+    (string Scheme, string Host, string ChannelNumber) : IRequest<Either<BaseError, ConcatPlaylist>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumberHandler.cs b/ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumberHandler.cs
index 517c1c2c3..2c1b90f77 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumberHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetConcatPlaylistByChannelNumberHandler.cs
@@ -1,35 +1,30 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Streaming.Queries
+namespace ErsatzTV.Application.Streaming;
+
+public class
+    GetConcatPlaylistByChannelNumberHandler : IRequestHandler<GetConcatPlaylistByChannelNumber,
+        Either<BaseError, ConcatPlaylist>>
 {
-    public class
-        GetConcatPlaylistByChannelNumberHandler : IRequestHandler<GetConcatPlaylistByChannelNumber,
-            Either<BaseError, ConcatPlaylist>>
-    {
-        private readonly IChannelRepository _channelRepository;
+    private readonly IChannelRepository _channelRepository;
 
-        public GetConcatPlaylistByChannelNumberHandler(IChannelRepository channelRepository) =>
-            _channelRepository = channelRepository;
+    public GetConcatPlaylistByChannelNumberHandler(IChannelRepository channelRepository) =>
+        _channelRepository = channelRepository;
 
-        public Task<Either<BaseError, ConcatPlaylist>> Handle(
-            GetConcatPlaylistByChannelNumber request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(channel => new ConcatPlaylist(request.Scheme, request.Host, channel.Number))
-                .Map(v => v.ToEither<ConcatPlaylist>());
+    public Task<Either<BaseError, ConcatPlaylist>> Handle(
+        GetConcatPlaylistByChannelNumber request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(channel => new ConcatPlaylist(request.Scheme, request.Host, channel.Number))
+            .Map(v => v.ToEither<ConcatPlaylist>());
 
-        private Task<Validation<BaseError, Channel>> Validate(GetConcatPlaylistByChannelNumber request) =>
-            ChannelMustExist(request);
+    private Task<Validation<BaseError, Channel>> Validate(GetConcatPlaylistByChannelNumber request) =>
+        ChannelMustExist(request);
 
-        private async Task<Validation<BaseError, Channel>> ChannelMustExist(GetConcatPlaylistByChannelNumber request) =>
-            (await _channelRepository.GetByNumber(request.ChannelNumber))
-            .ToValidation<BaseError>($"Channel number {request.ChannelNumber} does not exist.");
-    }
-}
+    private async Task<Validation<BaseError, Channel>> ChannelMustExist(GetConcatPlaylistByChannelNumber request) =>
+        (await _channelRepository.GetByNumber(request.ChannelNumber))
+        .ToValidation<BaseError>($"Channel number {request.ChannelNumber} does not exist.");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs b/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs
index 5a6f6621c..99e38057f 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumber.cs
@@ -1,22 +1,19 @@
-using System;
+namespace ErsatzTV.Application.Streaming;
 
-namespace ErsatzTV.Application.Streaming.Queries
+public record GetConcatProcessByChannelNumber : FFmpegProcessRequest
 {
-    public record GetConcatProcessByChannelNumber : FFmpegProcessRequest
+    public GetConcatProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
+        channelNumber,
+        "ts-legacy",
+        DateTimeOffset.Now,
+        false,
+        true,
+        0)
     {
-        public GetConcatProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
-            channelNumber,
-            "ts-legacy",
-            DateTimeOffset.Now,
-            false,
-            true,
-            0)
-        {
-            Scheme = scheme;
-            Host = host;
-        }
-
-        public string Scheme { get; }
-        public string Host { get; }
+        Scheme = scheme;
+        Host = host;
     }
-}
+
+    public string Scheme { get; }
+    public string Host { get; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs b/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs
index 8284e08d0..ad1de73cf 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetConcatProcessByChannelNumberHandler.cs
@@ -1,48 +1,44 @@
-using System;
-using System.Diagnostics;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.Streaming.Queries
+namespace ErsatzTV.Application.Streaming;
+
+public class GetConcatProcessByChannelNumberHandler : FFmpegProcessHandler<GetConcatProcessByChannelNumber>
 {
-    public class GetConcatProcessByChannelNumberHandler : FFmpegProcessHandler<GetConcatProcessByChannelNumber>
+    private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+
+    public GetConcatProcessByChannelNumberHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
+        : base(dbContextFactory)
     {
-        private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
-
-        public GetConcatProcessByChannelNumberHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
-            : base(dbContextFactory)
-        {
-            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
-        }
-
-        protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
-            TvContext dbContext,
-            GetConcatProcessByChannelNumber request,
-            Channel channel,
-            string ffmpegPath)
-        {
-            bool saveReports = await dbContext.ConfigElements
-                .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
-                .Map(result => result.IfNone(false));
-
-            IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-            Process process = ffmpegProcessService.ConcatChannel(
-                ffmpegPath,
-                saveReports,
-                channel,
-                request.Scheme,
-                request.Host);
-
-            return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
-        }
+        _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
     }
-}
+
+    protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
+        TvContext dbContext,
+        GetConcatProcessByChannelNumber request,
+        Channel channel,
+        string ffmpegPath)
+    {
+        bool saveReports = await dbContext.ConfigElements
+            .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+            .Map(result => result.IfNone(false));
+
+        IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
+        Process process = ffmpegProcessService.ConcatChannel(
+            ffmpegPath,
+            saveReports,
+            channel,
+            request.Scheme,
+            request.Host);
+
+        return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumber.cs b/ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumber.cs
index e836ddbe9..253491afc 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumber.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumber.cs
@@ -1,9 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Streaming.Queries
-{
-    public record GetHlsPlaylistByChannelNumber
-        (string Scheme, string Host, string ChannelNumber, string Mode) : IRequest<Either<BaseError, string>>;
-}
+namespace ErsatzTV.Application.Streaming;
+
+public record GetHlsPlaylistByChannelNumber
+    (string Scheme, string Host, string ChannelNumber, string Mode) : IRequest<Either<BaseError, string>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumberHandler.cs b/ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumberHandler.cs
index c42a627fc..1032ef037 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumberHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetHlsPlaylistByChannelNumberHandler.cs
@@ -1,54 +1,49 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Caching.Memory;
 
-namespace ErsatzTV.Application.Streaming.Queries
+namespace ErsatzTV.Application.Streaming;
+
+public class GetHlsPlaylistByChannelNumberHandler :
+    IRequestHandler<GetHlsPlaylistByChannelNumber, Either<BaseError, string>>
 {
-    public class GetHlsPlaylistByChannelNumberHandler :
-        IRequestHandler<GetHlsPlaylistByChannelNumber, Either<BaseError, string>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IMemoryCache _memoryCache;
+
+    public GetHlsPlaylistByChannelNumberHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IMemoryCache memoryCache)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IMemoryCache _memoryCache;
+        _dbContextFactory = dbContextFactory;
+        _memoryCache = memoryCache;
+    }
 
-        public GetHlsPlaylistByChannelNumberHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IMemoryCache memoryCache)
-        {
-            _dbContextFactory = dbContextFactory;
-            _memoryCache = memoryCache;
-        }
+    public async Task<Either<BaseError, string>> Handle(
+        GetHlsPlaylistByChannelNumber request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        DateTimeOffset now = DateTimeOffset.Now;
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request, now);
+        return await LanguageExtensions.Apply(validation, parameters => GetPlaylist(dbContext, request, parameters, now));
+    }
 
-        public async Task<Either<BaseError, string>> Handle(
-            GetHlsPlaylistByChannelNumber request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            DateTimeOffset now = DateTimeOffset.Now;
-            Validation<BaseError, Parameters> validation = await Validate(dbContext, request, now);
-            return await validation.Apply(parameters => GetPlaylist(dbContext, request, parameters, now));
-        }
+    private Task<string> GetPlaylist(
+        TvContext dbContext,
+        GetHlsPlaylistByChannelNumber request,
+        Parameters parameters,
+        DateTimeOffset now)
+    {
+        string mode = string.IsNullOrWhiteSpace(request.Mode)
+            ? string.Empty
+            : $"&mode={request.Mode}";
 
-        private Task<string> GetPlaylist(
-            TvContext dbContext,
-            GetHlsPlaylistByChannelNumber request,
-            Parameters parameters,
-            DateTimeOffset now)
-        {
-            string mode = string.IsNullOrWhiteSpace(request.Mode)
-                ? string.Empty
-                : $"&mode={request.Mode}";
-
-            long index = GetIndexForChannel(parameters.Channel, parameters.PlayoutItem);
-            double timeRemaining = Math.Abs((parameters.PlayoutItem.FinishOffset - now).TotalSeconds);
-            return $@"#EXTM3U
+        long index = GetIndexForChannel(parameters.Channel, parameters.PlayoutItem);
+        double timeRemaining = Math.Abs((parameters.PlayoutItem.FinishOffset - now).TotalSeconds);
+        return $@"#EXTM3U
 #EXT-X-VERSION:3
 #EXT-X-TARGETDURATION:10
 #EXT-X-MEDIA-SEQUENCE:{index}
@@ -56,62 +51,61 @@ namespace ErsatzTV.Application.Streaming.Queries
 #EXTINF:{timeRemaining:F2},
 {request.Scheme}://{request.Host}/ffmpeg/stream/{request.ChannelNumber}?index={index}{mode}
 ".AsTask();
-        }
+    }
 
-        private Task<Validation<BaseError, Parameters>> Validate(
-            TvContext dbContext,
-            GetHlsPlaylistByChannelNumber request,
-            DateTimeOffset now) =>
-            ChannelMustExist(dbContext, request)
-                .BindT(channel => PlayoutItemMustExist(dbContext, channel, now));
+    private Task<Validation<BaseError, Parameters>> Validate(
+        TvContext dbContext,
+        GetHlsPlaylistByChannelNumber request,
+        DateTimeOffset now) =>
+        ChannelMustExist(dbContext, request)
+            .BindT(channel => PlayoutItemMustExist(dbContext, channel, now));
 
-        private static Task<Validation<BaseError, Channel>> ChannelMustExist(
-            TvContext dbContext,
-            GetHlsPlaylistByChannelNumber request) =>
-            dbContext.Channels
-                .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber)
-                .Map(o => o.ToValidation<BaseError>($"Channel number {request.ChannelNumber} does not exist."));
+    private static Task<Validation<BaseError, Channel>> ChannelMustExist(
+        TvContext dbContext,
+        GetHlsPlaylistByChannelNumber request) =>
+        dbContext.Channels
+            .SelectOneAsync(c => c.Number, c => c.Number == request.ChannelNumber)
+            .Map(o => o.ToValidation<BaseError>($"Channel number {request.ChannelNumber} does not exist."));
 
-        private static Task<Validation<BaseError, Parameters>> PlayoutItemMustExist(
-            TvContext dbContext,
-            Channel channel,
-            DateTimeOffset now) =>
-            dbContext.PlayoutItems
-                .ForChannelAndTime(channel.Id, now)
-                .MapT(playoutItem => new Parameters(channel, playoutItem))
-                .Map(o => o.ToValidation<BaseError>($"Unable to locate playout item for channel {channel.Number}"));
+    private static Task<Validation<BaseError, Parameters>> PlayoutItemMustExist(
+        TvContext dbContext,
+        Channel channel,
+        DateTimeOffset now) =>
+        dbContext.PlayoutItems
+            .ForChannelAndTime(channel.Id, now)
+            .MapT(playoutItem => new Parameters(channel, playoutItem))
+            .Map(o => o.ToValidation<BaseError>($"Unable to locate playout item for channel {channel.Number}"));
 
-        private long GetIndexForChannel(Channel channel, PlayoutItem playoutItem)
+    private long GetIndexForChannel(Channel channel, PlayoutItem playoutItem)
+    {
+        long ticks = playoutItem.Start.Ticks;
+        var key = new ChannelIndexKey(channel.Id);
+
+        long index;
+        if (_memoryCache.TryGetValue(key, out ChannelIndexRecord channelRecord))
         {
-            long ticks = playoutItem.Start.Ticks;
-            var key = new ChannelIndexKey(channel.Id);
-
-            long index;
-            if (_memoryCache.TryGetValue(key, out ChannelIndexRecord channelRecord))
+            if (channelRecord.StartTicks == ticks)
             {
-                if (channelRecord.StartTicks == ticks)
-                {
-                    index = channelRecord.Index;
-                }
-                else
-                {
-                    index = channelRecord.Index + 1;
-                    _memoryCache.Set(key, new ChannelIndexRecord(ticks, index), TimeSpan.FromDays(1));
-                }
+                index = channelRecord.Index;
             }
             else
             {
-                index = 1;
+                index = channelRecord.Index + 1;
                 _memoryCache.Set(key, new ChannelIndexRecord(ticks, index), TimeSpan.FromDays(1));
             }
-
-            return index;
+        }
+        else
+        {
+            index = 1;
+            _memoryCache.Set(key, new ChannelIndexRecord(ticks, index), TimeSpan.FromDays(1));
         }
 
-        private record ChannelIndexKey(int ChannelId);
-
-        private record ChannelIndexRecord(long StartTicks, long Index);
-
-        private record Parameters(Channel Channel, PlayoutItem PlayoutItem);
+        return index;
     }
-}
+
+    private record ChannelIndexKey(int ChannelId);
+
+    private record ChannelIndexRecord(long StartTicks, long Index);
+
+    private record Parameters(Channel Channel, PlayoutItem PlayoutItem);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetLastPtsDuration.cs b/ErsatzTV.Application/Streaming/Queries/GetLastPtsDuration.cs
index bdd289d12..8a424b20e 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetLastPtsDuration.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetLastPtsDuration.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Streaming.Queries;
+namespace ErsatzTV.Application.Streaming;
 
 public record GetLastPtsDuration(string FileName) : IRequest<Either<BaseError, PtsAndDuration>>;
diff --git a/ErsatzTV.Application/Streaming/Queries/GetLastPtsDurationHandler.cs b/ErsatzTV.Application/Streaming/Queries/GetLastPtsDurationHandler.cs
index fce411c73..71348b0d5 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetLastPtsDurationHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetLastPtsDurationHandler.cs
@@ -1,16 +1,10 @@
 using System.Diagnostics;
-using System.IO;
-using System.Linq;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Streaming.Queries;
+namespace ErsatzTV.Application.Streaming;
 
 public class GetLastPtsDurationHandler : IRequestHandler<GetLastPtsDuration, Either<BaseError, PtsAndDuration>>
 {
diff --git a/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumber.cs b/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumber.cs
index 2c735d656..fbb644843 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumber.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumber.cs
@@ -1,18 +1,14 @@
-using System;
-using LanguageExt;
+namespace ErsatzTV.Application.Streaming;
 
-namespace ErsatzTV.Application.Streaming.Queries
-{
-    public record GetPlayoutItemProcessByChannelNumber(string ChannelNumber,
-        string Mode,
-        DateTimeOffset Now,
-        bool StartAtZero,
-        bool HlsRealtime,
-        long PtsOffset,
-        Option<int> TargetFramerate) : FFmpegProcessRequest(ChannelNumber,
-        Mode,
-        Now,
-        StartAtZero,
-        HlsRealtime,
-        PtsOffset);
-}
+public record GetPlayoutItemProcessByChannelNumber(string ChannelNumber,
+    string Mode,
+    DateTimeOffset Now,
+    bool StartAtZero,
+    bool HlsRealtime,
+    long PtsOffset,
+    Option<int> TargetFramerate) : FFmpegProcessRequest(ChannelNumber,
+    Mode,
+    Now,
+    StartAtZero,
+    HlsRealtime,
+    PtsOffset);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs b/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs
index e0910b28c..00bbef6e2 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetPlayoutItemProcessByChannelNumberHandler.cs
@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
@@ -18,273 +14,160 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Streaming.Queries
+namespace ErsatzTV.Application.Streaming;
+
+public class GetPlayoutItemProcessByChannelNumberHandler :
+    FFmpegProcessHandler<GetPlayoutItemProcessByChannelNumber>
 {
-    public class GetPlayoutItemProcessByChannelNumberHandler :
-        FFmpegProcessHandler<GetPlayoutItemProcessByChannelNumber>
+    private readonly IEmbyPathReplacementService _embyPathReplacementService;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+    private readonly IArtistRepository _artistRepository;
+    private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
+    private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly IPlexPathReplacementService _plexPathReplacementService;
+    private readonly ISongVideoGenerator _songVideoGenerator;
+
+    public GetPlayoutItemProcessByChannelNumberHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
+        ILocalFileSystem localFileSystem,
+        IPlexPathReplacementService plexPathReplacementService,
+        IJellyfinPathReplacementService jellyfinPathReplacementService,
+        IEmbyPathReplacementService embyPathReplacementService,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ITelevisionRepository televisionRepository,
+        IArtistRepository artistRepository,
+        ISongVideoGenerator songVideoGenerator)
+        : base(dbContextFactory)
     {
-        private readonly IEmbyPathReplacementService _embyPathReplacementService;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-        private readonly ITelevisionRepository _televisionRepository;
-        private readonly IArtistRepository _artistRepository;
-        private readonly IJellyfinPathReplacementService _jellyfinPathReplacementService;
-        private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly IPlexPathReplacementService _plexPathReplacementService;
-        private readonly ISongVideoGenerator _songVideoGenerator;
+        _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
+        _localFileSystem = localFileSystem;
+        _plexPathReplacementService = plexPathReplacementService;
+        _jellyfinPathReplacementService = jellyfinPathReplacementService;
+        _embyPathReplacementService = embyPathReplacementService;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _televisionRepository = televisionRepository;
+        _artistRepository = artistRepository;
+        _songVideoGenerator = songVideoGenerator;
+    }
 
-        public GetPlayoutItemProcessByChannelNumberHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
-            ILocalFileSystem localFileSystem,
-            IPlexPathReplacementService plexPathReplacementService,
-            IJellyfinPathReplacementService jellyfinPathReplacementService,
-            IEmbyPathReplacementService embyPathReplacementService,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ITelevisionRepository televisionRepository,
-            IArtistRepository artistRepository,
-            ISongVideoGenerator songVideoGenerator)
-            : base(dbContextFactory)
-        {
-            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
-            _localFileSystem = localFileSystem;
-            _plexPathReplacementService = plexPathReplacementService;
-            _jellyfinPathReplacementService = jellyfinPathReplacementService;
-            _embyPathReplacementService = embyPathReplacementService;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _televisionRepository = televisionRepository;
-            _artistRepository = artistRepository;
-            _songVideoGenerator = songVideoGenerator;
-        }
-
-        protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
-            TvContext dbContext,
-            GetPlayoutItemProcessByChannelNumber request,
-            Channel channel,
-            string ffmpegPath)
-        {
-            DateTimeOffset now = request.Now;
+    protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
+        TvContext dbContext,
+        GetPlayoutItemProcessByChannelNumber request,
+        Channel channel,
+        string ffmpegPath)
+    {
+        DateTimeOffset now = request.Now;
             
-            Either<BaseError, PlayoutItemWithPath> maybePlayoutItem = await dbContext.PlayoutItems
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Episode).MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Movie).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Movie).MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
-                .ThenInclude(ov => ov.MediaFiles)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
-                .ThenInclude(ov => ov.Streams)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Song).MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Song).MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(i => i.MediaItem)
-                .ThenInclude(mi => (mi as Song).SongMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .ForChannelAndTime(channel.Id, now)
-                .Map(o => o.ToEither<BaseError>(new UnableToLocatePlayoutItem()))
-                .BindT(ValidatePlayoutItemPath);
+        Either<BaseError, PlayoutItemWithPath> maybePlayoutItem = await dbContext.PlayoutItems
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Episode).MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Movie).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Movie).MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as MusicVideo).MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+            .ThenInclude(ov => ov.MediaFiles)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+            .ThenInclude(ov => ov.Streams)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Song).MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Song).MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(i => i.MediaItem)
+            .ThenInclude(mi => (mi as Song).SongMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .ForChannelAndTime(channel.Id, now)
+            .Map(o => o.ToEither<BaseError>(new UnableToLocatePlayoutItem()))
+            .BindT(ValidatePlayoutItemPath);
 
-            if (maybePlayoutItem.LeftAsEnumerable().Any(e => e is UnableToLocatePlayoutItem))
-            {
-                maybePlayoutItem = await CheckForFallbackFiller(dbContext, channel, now);
-            }
-
-            IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-
-            return await maybePlayoutItem.Match(
-                async playoutItemWithPath =>
-                {
-                    MediaVersion version = playoutItemWithPath.PlayoutItem.MediaItem.GetHeadVersion();
-
-                    string videoPath = playoutItemWithPath.Path;
-                    MediaVersion videoVersion = version;
-
-                    string audioPath = playoutItemWithPath.Path;
-                    MediaVersion audioVersion = version;
-
-                    Option<ChannelWatermark> maybeGlobalWatermark = await dbContext.ConfigElements
-                        .GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId)
-                        .BindT(
-                            watermarkId => dbContext.ChannelWatermarks
-                                .SelectOneAsync(w => w.Id, w => w.Id == watermarkId));
-
-                    if (playoutItemWithPath.PlayoutItem.MediaItem is Song song)
-                    {
-                        (videoPath, videoVersion) = await _songVideoGenerator.GenerateSongVideo(
-                            song,
-                            channel,
-                            maybeGlobalWatermark,
-                            ffmpegPath);
-                    }
-
-                    bool saveReports = await dbContext.ConfigElements
-                        .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
-                        .Map(result => result.IfNone(false));
-
-                    Process process = await ffmpegProcessService.ForPlayoutItem(
-                        ffmpegPath,
-                        saveReports,
-                        channel,
-                        videoVersion,
-                        audioVersion,
-                        videoPath,
-                        audioPath,
-                        playoutItemWithPath.PlayoutItem.StartOffset,
-                        playoutItemWithPath.PlayoutItem.FinishOffset,
-                        request.StartAtZero ? playoutItemWithPath.PlayoutItem.StartOffset : now,
-                        maybeGlobalWatermark,
-                        channel.FFmpegProfile.VaapiDriver,
-                        channel.FFmpegProfile.VaapiDevice,
-                        request.HlsRealtime,
-                        playoutItemWithPath.PlayoutItem.FillerKind,
-                        playoutItemWithPath.PlayoutItem.InPoint,
-                        playoutItemWithPath.PlayoutItem.OutPoint,
-                        request.PtsOffset,
-                        request.TargetFramerate);
-
-                    var result = new PlayoutItemProcessModel(process, playoutItemWithPath.PlayoutItem.FinishOffset);
-
-                    return Right<BaseError, PlayoutItemProcessModel>(result);
-                },
-                async error =>
-                {
-                    var offlineTranscodeMessage =
-                        $"offline image is unavailable because transcoding is disabled in ffmpeg profile '{channel.FFmpegProfile.Name}'";
-
-                    Option<TimeSpan> maybeDuration = await Optional(channel.FFmpegProfile.Transcode)
-                        .Where(transcode => transcode)
-                        .Match(
-                            _ => dbContext.PlayoutItems
-                                .Filter(pi => pi.Playout.ChannelId == channel.Id)
-                                .Filter(pi => pi.Start > now.UtcDateTime)
-                                .OrderBy(pi => pi.Start)
-                                .FirstOrDefaultAsync()
-                                .Map(Optional)
-                                .MapT(pi => pi.StartOffset - now),
-                            () => Option<TimeSpan>.None.AsTask());
-
-                    DateTimeOffset finish = maybeDuration.Match(d => now.Add(d), () => now);
-
-                    switch (error)
-                    {
-                        case UnableToLocatePlayoutItem:
-                            if (channel.FFmpegProfile.Transcode)
-                            {
-                                Process errorProcess = await ffmpegProcessService.ForError(
-                                    ffmpegPath,
-                                    channel,
-                                    maybeDuration,
-                                    "Channel is Offline",
-                                    request.HlsRealtime,
-                                    request.PtsOffset);
-                                
-                                return new PlayoutItemProcessModel(errorProcess, finish);
-                            }
-                            else
-                            {
-                                var message =
-                                    $"Unable to locate playout item for channel {channel.Number}; {offlineTranscodeMessage}";
-
-                                return BaseError.New(message);
-                            }
-                        case PlayoutItemDoesNotExistOnDisk:
-                            if (channel.FFmpegProfile.Transcode)
-                            {
-                                Process errorProcess = await ffmpegProcessService.ForError(
-                                    ffmpegPath,
-                                    channel,
-                                    maybeDuration,
-                                    error.Value,
-                                    request.HlsRealtime,
-                                    request.PtsOffset);
-
-                                return new PlayoutItemProcessModel(errorProcess, finish);
-                            }
-                            else
-                            {
-                                var message =
-                                    $"Playout item does not exist on disk for channel {channel.Number}; {offlineTranscodeMessage}";
-
-                                return BaseError.New(message);
-                            }
-                        default:
-                            if (channel.FFmpegProfile.Transcode)
-                            {
-                                Process errorProcess = await ffmpegProcessService.ForError(
-                                    ffmpegPath,
-                                    channel,
-                                    maybeDuration,
-                                    "Channel is Offline",
-                                    request.HlsRealtime,
-                                    request.PtsOffset);
-
-                                return new PlayoutItemProcessModel(errorProcess, finish);
-                            }
-                            else
-                            {
-                                var message =
-                                    $"Unexpected error locating playout item for channel {channel.Number}; {offlineTranscodeMessage}";
-
-                                return BaseError.New(message);
-                            }
-                    }
-                });
+        if (maybePlayoutItem.LeftAsEnumerable().Any(e => e is UnableToLocatePlayoutItem))
+        {
+            maybePlayoutItem = await CheckForFallbackFiller(dbContext, channel, now);
         }
 
-        private async Task<Either<BaseError, PlayoutItemWithPath>> CheckForFallbackFiller(
-            TvContext dbContext,
-            Channel channel,
-            DateTimeOffset now)
-        {
-            // check for channel fallback
-            Option<FillerPreset> maybeFallback = await dbContext.FillerPresets
-                .SelectOneAsync(w => w.Id, w => w.Id == channel.FallbackFillerId);
+        IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
 
-            // then check for global fallback
-            if (maybeFallback.IsNone)
+        return await maybePlayoutItem.Match(
+            async playoutItemWithPath =>
             {
-                maybeFallback = await dbContext.ConfigElements
-                    .GetValue<int>(ConfigElementKey.FFmpegGlobalFallbackFillerId)
-                    .BindT(fillerId => dbContext.FillerPresets.SelectOneAsync(w => w.Id, w => w.Id == fillerId));
-            }
+                MediaVersion version = playoutItemWithPath.PlayoutItem.MediaItem.GetHeadVersion();
 
-            foreach (FillerPreset fallbackPreset in maybeFallback)
+                string videoPath = playoutItemWithPath.Path;
+                MediaVersion videoVersion = version;
+
+                string audioPath = playoutItemWithPath.Path;
+                MediaVersion audioVersion = version;
+
+                Option<ChannelWatermark> maybeGlobalWatermark = await dbContext.ConfigElements
+                    .GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId)
+                    .BindT(
+                        watermarkId => dbContext.ChannelWatermarks
+                            .SelectOneAsync(w => w.Id, w => w.Id == watermarkId));
+
+                if (playoutItemWithPath.PlayoutItem.MediaItem is Song song)
+                {
+                    (videoPath, videoVersion) = await _songVideoGenerator.GenerateSongVideo(
+                        song,
+                        channel,
+                        maybeGlobalWatermark,
+                        ffmpegPath);
+                }
+
+                bool saveReports = await dbContext.ConfigElements
+                    .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+                    .Map(result => result.IfNone(false));
+
+                Process process = await ffmpegProcessService.ForPlayoutItem(
+                    ffmpegPath,
+                    saveReports,
+                    channel,
+                    videoVersion,
+                    audioVersion,
+                    videoPath,
+                    audioPath,
+                    playoutItemWithPath.PlayoutItem.StartOffset,
+                    playoutItemWithPath.PlayoutItem.FinishOffset,
+                    request.StartAtZero ? playoutItemWithPath.PlayoutItem.StartOffset : now,
+                    maybeGlobalWatermark,
+                    channel.FFmpegProfile.VaapiDriver,
+                    channel.FFmpegProfile.VaapiDevice,
+                    request.HlsRealtime,
+                    playoutItemWithPath.PlayoutItem.FillerKind,
+                    playoutItemWithPath.PlayoutItem.InPoint,
+                    playoutItemWithPath.PlayoutItem.OutPoint,
+                    request.PtsOffset,
+                    request.TargetFramerate);
+
+                var result = new PlayoutItemProcessModel(process, playoutItemWithPath.PlayoutItem.FinishOffset);
+
+                return Right<BaseError, PlayoutItemProcessModel>(result);
+            },
+            async error =>
             {
-                // turn this into a playout item
+                var offlineTranscodeMessage =
+                    $"offline image is unavailable because transcoding is disabled in ffmpeg profile '{channel.FFmpegProfile.Name}'";
 
-                var collectionKey = CollectionKey.ForFillerPreset(fallbackPreset);
-                List<MediaItem> items = await MediaItemsForCollection.Collect(
-                    _mediaCollectionRepository,
-                    _televisionRepository,
-                    _artistRepository,
-                    collectionKey);
-
-                // TODO: shuffle? does it really matter since we loop anyway
-                MediaItem item = items[new Random().Next(items.Count)];
-                
                 Option<TimeSpan> maybeDuration = await Optional(channel.FFmpegProfile.Transcode)
                     .Where(transcode => transcode)
                     .Match(
@@ -297,87 +180,197 @@ namespace ErsatzTV.Application.Streaming.Queries
                             .MapT(pi => pi.StartOffset - now),
                         () => Option<TimeSpan>.None.AsTask());
 
-                MediaVersion version = item.GetHeadVersion();
+                DateTimeOffset finish = maybeDuration.Match(d => now.Add(d), () => now);
 
-                version.MediaFiles = await dbContext.MediaFiles
-                    .AsNoTracking()
-                    .Filter(mf => mf.MediaVersionId == version.Id)
-                    .ToListAsync();
-
-                version.Streams = await dbContext.MediaStreams
-                    .AsNoTracking()
-                    .Filter(ms => ms.MediaVersionId == version.Id)
-                    .ToListAsync();
-
-                DateTimeOffset finish = maybeDuration.Match(
-                    // next playout item exists
-                    // loop until it starts
-                    now.Add,
-                    // no next playout item exists
-                    // loop for 5 minutes if less than 30s, otherwise play full item
-                    () => version.Duration < TimeSpan.FromSeconds(30)
-                        ? now.AddMinutes(5)
-                        : now.Add(version.Duration));
-
-                var playoutItem = new PlayoutItem
+                switch (error)
                 {
-                    MediaItem = item,
-                    MediaItemId = item.Id,
-                    Start = now.UtcDateTime,
-                    Finish = finish.UtcDateTime,
-                    FillerKind = FillerKind.Fallback,
-                    InPoint = TimeSpan.Zero,
-                    OutPoint = version.Duration
-                };
-                
-                return await ValidatePlayoutItemPath(playoutItem);
-            }
+                    case UnableToLocatePlayoutItem:
+                        if (channel.FFmpegProfile.Transcode)
+                        {
+                            Process errorProcess = await ffmpegProcessService.ForError(
+                                ffmpegPath,
+                                channel,
+                                maybeDuration,
+                                "Channel is Offline",
+                                request.HlsRealtime,
+                                request.PtsOffset);
+                                
+                            return new PlayoutItemProcessModel(errorProcess, finish);
+                        }
+                        else
+                        {
+                            var message =
+                                $"Unable to locate playout item for channel {channel.Number}; {offlineTranscodeMessage}";
 
-            return new UnableToLocatePlayoutItem();
-        }
+                            return BaseError.New(message);
+                        }
+                    case PlayoutItemDoesNotExistOnDisk:
+                        if (channel.FFmpegProfile.Transcode)
+                        {
+                            Process errorProcess = await ffmpegProcessService.ForError(
+                                ffmpegPath,
+                                channel,
+                                maybeDuration,
+                                error.Value,
+                                request.HlsRealtime,
+                                request.PtsOffset);
 
-        private async Task<Either<BaseError, PlayoutItemWithPath>> ValidatePlayoutItemPath(PlayoutItem playoutItem)
-        {
-            string path = await GetPlayoutItemPath(playoutItem);
+                            return new PlayoutItemProcessModel(errorProcess, finish);
+                        }
+                        else
+                        {
+                            var message =
+                                $"Playout item does not exist on disk for channel {channel.Number}; {offlineTranscodeMessage}";
 
-            if (_localFileSystem.FileExists(path))
-            {
-                return new PlayoutItemWithPath(playoutItem, path);
-            }
+                            return BaseError.New(message);
+                        }
+                    default:
+                        if (channel.FFmpegProfile.Transcode)
+                        {
+                            Process errorProcess = await ffmpegProcessService.ForError(
+                                ffmpegPath,
+                                channel,
+                                maybeDuration,
+                                "Channel is Offline",
+                                request.HlsRealtime,
+                                request.PtsOffset);
 
-            return new PlayoutItemDoesNotExistOnDisk(path);
-        }
+                            return new PlayoutItemProcessModel(errorProcess, finish);
+                        }
+                        else
+                        {
+                            var message =
+                                $"Unexpected error locating playout item for channel {channel.Number}; {offlineTranscodeMessage}";
 
-        private async Task<string> GetPlayoutItemPath(PlayoutItem playoutItem)
-        {
-            MediaVersion version = playoutItem.MediaItem.GetHeadVersion();
-
-            MediaFile file = version.MediaFiles.Head();
-            string path = file.Path;
-            return playoutItem.MediaItem switch
-            {
-                PlexMovie plexMovie => await _plexPathReplacementService.GetReplacementPlexPath(
-                    plexMovie.LibraryPathId,
-                    path),
-                PlexEpisode plexEpisode => await _plexPathReplacementService.GetReplacementPlexPath(
-                    plexEpisode.LibraryPathId,
-                    path),
-                JellyfinMovie jellyfinMovie => await _jellyfinPathReplacementService.GetReplacementJellyfinPath(
-                    jellyfinMovie.LibraryPathId,
-                    path),
-                JellyfinEpisode jellyfinEpisode => await _jellyfinPathReplacementService.GetReplacementJellyfinPath(
-                    jellyfinEpisode.LibraryPathId,
-                    path),
-                EmbyMovie embyMovie => await _embyPathReplacementService.GetReplacementEmbyPath(
-                    embyMovie.LibraryPathId,
-                    path),
-                EmbyEpisode embyEpisode => await _embyPathReplacementService.GetReplacementEmbyPath(
-                    embyEpisode.LibraryPathId,
-                    path),
-                _ => path
-            };
-        }
-
-        private record PlayoutItemWithPath(PlayoutItem PlayoutItem, string Path);
+                            return BaseError.New(message);
+                        }
+                }
+            });
     }
-}
+
+    private async Task<Either<BaseError, PlayoutItemWithPath>> CheckForFallbackFiller(
+        TvContext dbContext,
+        Channel channel,
+        DateTimeOffset now)
+    {
+        // check for channel fallback
+        Option<FillerPreset> maybeFallback = await dbContext.FillerPresets
+            .SelectOneAsync(w => w.Id, w => w.Id == channel.FallbackFillerId);
+
+        // then check for global fallback
+        if (maybeFallback.IsNone)
+        {
+            maybeFallback = await dbContext.ConfigElements
+                .GetValue<int>(ConfigElementKey.FFmpegGlobalFallbackFillerId)
+                .BindT(fillerId => dbContext.FillerPresets.SelectOneAsync(w => w.Id, w => w.Id == fillerId));
+        }
+
+        foreach (FillerPreset fallbackPreset in maybeFallback)
+        {
+            // turn this into a playout item
+
+            var collectionKey = CollectionKey.ForFillerPreset(fallbackPreset);
+            List<MediaItem> items = await MediaItemsForCollection.Collect(
+                _mediaCollectionRepository,
+                _televisionRepository,
+                _artistRepository,
+                collectionKey);
+
+            // TODO: shuffle? does it really matter since we loop anyway
+            MediaItem item = items[new Random().Next(items.Count)];
+                
+            Option<TimeSpan> maybeDuration = await Optional(channel.FFmpegProfile.Transcode)
+                .Where(transcode => transcode)
+                .Match(
+                    _ => dbContext.PlayoutItems
+                        .Filter(pi => pi.Playout.ChannelId == channel.Id)
+                        .Filter(pi => pi.Start > now.UtcDateTime)
+                        .OrderBy(pi => pi.Start)
+                        .FirstOrDefaultAsync()
+                        .Map(Optional)
+                        .MapT(pi => pi.StartOffset - now),
+                    () => Option<TimeSpan>.None.AsTask());
+
+            MediaVersion version = item.GetHeadVersion();
+
+            version.MediaFiles = await dbContext.MediaFiles
+                .AsNoTracking()
+                .Filter(mf => mf.MediaVersionId == version.Id)
+                .ToListAsync();
+
+            version.Streams = await dbContext.MediaStreams
+                .AsNoTracking()
+                .Filter(ms => ms.MediaVersionId == version.Id)
+                .ToListAsync();
+
+            DateTimeOffset finish = maybeDuration.Match(
+                // next playout item exists
+                // loop until it starts
+                now.Add,
+                // no next playout item exists
+                // loop for 5 minutes if less than 30s, otherwise play full item
+                () => version.Duration < TimeSpan.FromSeconds(30)
+                    ? now.AddMinutes(5)
+                    : now.Add(version.Duration));
+
+            var playoutItem = new PlayoutItem
+            {
+                MediaItem = item,
+                MediaItemId = item.Id,
+                Start = now.UtcDateTime,
+                Finish = finish.UtcDateTime,
+                FillerKind = FillerKind.Fallback,
+                InPoint = TimeSpan.Zero,
+                OutPoint = version.Duration
+            };
+                
+            return await ValidatePlayoutItemPath(playoutItem);
+        }
+
+        return new UnableToLocatePlayoutItem();
+    }
+
+    private async Task<Either<BaseError, PlayoutItemWithPath>> ValidatePlayoutItemPath(PlayoutItem playoutItem)
+    {
+        string path = await GetPlayoutItemPath(playoutItem);
+
+        if (_localFileSystem.FileExists(path))
+        {
+            return new PlayoutItemWithPath(playoutItem, path);
+        }
+
+        return new PlayoutItemDoesNotExistOnDisk(path);
+    }
+
+    private async Task<string> GetPlayoutItemPath(PlayoutItem playoutItem)
+    {
+        MediaVersion version = playoutItem.MediaItem.GetHeadVersion();
+
+        MediaFile file = version.MediaFiles.Head();
+        string path = file.Path;
+        return playoutItem.MediaItem switch
+        {
+            PlexMovie plexMovie => await _plexPathReplacementService.GetReplacementPlexPath(
+                plexMovie.LibraryPathId,
+                path),
+            PlexEpisode plexEpisode => await _plexPathReplacementService.GetReplacementPlexPath(
+                plexEpisode.LibraryPathId,
+                path),
+            JellyfinMovie jellyfinMovie => await _jellyfinPathReplacementService.GetReplacementJellyfinPath(
+                jellyfinMovie.LibraryPathId,
+                path),
+            JellyfinEpisode jellyfinEpisode => await _jellyfinPathReplacementService.GetReplacementJellyfinPath(
+                jellyfinEpisode.LibraryPathId,
+                path),
+            EmbyMovie embyMovie => await _embyPathReplacementService.GetReplacementEmbyPath(
+                embyMovie.LibraryPathId,
+                path),
+            EmbyEpisode embyEpisode => await _embyPathReplacementService.GetReplacementEmbyPath(
+                embyEpisode.LibraryPathId,
+                path),
+            _ => path
+        };
+    }
+
+    private record PlayoutItemWithPath(PlayoutItem PlayoutItem, string Path);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumber.cs b/ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumber.cs
index 71b6b7b37..6f3db9bba 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumber.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumber.cs
@@ -1,22 +1,19 @@
-using System;
+namespace ErsatzTV.Application.Streaming;
 
-namespace ErsatzTV.Application.Streaming.Queries
+public record GetWrappedProcessByChannelNumber : FFmpegProcessRequest
 {
-    public record GetWrappedProcessByChannelNumber : FFmpegProcessRequest
+    public GetWrappedProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
+        channelNumber,
+        "ts",
+        DateTimeOffset.Now,
+        false,
+        true,
+        0)
     {
-        public GetWrappedProcessByChannelNumber(string scheme, string host, string channelNumber) : base(
-            channelNumber,
-            "ts",
-            DateTimeOffset.Now,
-            false,
-            true,
-            0)
-        {
-            Scheme = scheme;
-            Host = host;
-        }
-
-        public string Scheme { get; }
-        public string Host { get; }
+        Scheme = scheme;
+        Host = host;
     }
-}
+
+    public string Scheme { get; }
+    public string Host { get; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumberHandler.cs b/ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumberHandler.cs
index 38199363b..3a0e606a8 100644
--- a/ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumberHandler.cs
+++ b/ErsatzTV.Application/Streaming/Queries/GetWrappedProcessByChannelNumberHandler.cs
@@ -1,48 +1,44 @@
-using System;
-using System.Diagnostics;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.Streaming.Queries
+namespace ErsatzTV.Application.Streaming;
+
+public class GetWrappedProcessByChannelNumberHandler : FFmpegProcessHandler<GetWrappedProcessByChannelNumber>
 {
-    public class GetWrappedProcessByChannelNumberHandler : FFmpegProcessHandler<GetWrappedProcessByChannelNumber>
+    private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+
+    public GetWrappedProcessByChannelNumberHandler(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
+        : base(dbContextFactory)
     {
-        private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
-
-        public GetWrappedProcessByChannelNumberHandler(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
-            : base(dbContextFactory)
-        {
-            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
-        }
-
-        protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
-            TvContext dbContext,
-            GetWrappedProcessByChannelNumber request,
-            Channel channel,
-            string ffmpegPath)
-        {
-            bool saveReports = await dbContext.ConfigElements
-                .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
-                .Map(result => result.IfNone(false));
-
-            IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-            Process process = ffmpegProcessService.WrapSegmenter(
-                ffmpegPath,
-                saveReports,
-                channel,
-                request.Scheme,
-                request.Host);
-
-            return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
-        }
+        _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
     }
-}
+
+    protected override async Task<Either<BaseError, PlayoutItemProcessModel>> GetProcess(
+        TvContext dbContext,
+        GetWrappedProcessByChannelNumber request,
+        Channel channel,
+        string ffmpegPath)
+    {
+        bool saveReports = await dbContext.ConfigElements
+            .GetValue<bool>(ConfigElementKey.FFmpegSaveReports)
+            .Map(result => result.IfNone(false));
+
+        IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
+        Process process = ffmpegProcessService.WrapSegmenter(
+            ffmpegPath,
+            saveReports,
+            channel,
+            request.Scheme,
+            request.Host);
+
+        return new PlayoutItemProcessModel(process, DateTimeOffset.MaxValue);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Mapper.cs b/ErsatzTV.Application/Television/Mapper.cs
index d712ceb71..6b261d612 100644
--- a/ErsatzTV.Application/Television/Mapper.cs
+++ b/ErsatzTV.Application/Television/Mapper.cs
@@ -1,119 +1,113 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Jellyfin;
 using Flurl;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Application.Television
+namespace ErsatzTV.Application.Television;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        internal static TelevisionShowViewModel ProjectToViewModel(
-            Show show,
-            List<string> languages,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby) =>
-            new(
-                show.Id,
-                show.ShowMetadata.HeadOrNone().Map(m => m.Title ?? string.Empty).IfNone(string.Empty),
-                show.ShowMetadata.HeadOrNone().Map(m => m.Year?.ToString() ?? string.Empty).IfNone(string.Empty),
-                show.ShowMetadata.HeadOrNone().Map(m => m.Plot ?? string.Empty).IfNone(string.Empty),
-                show.ShowMetadata.HeadOrNone().Map(m => GetPoster(m, maybeJellyfin, maybeEmby)).IfNone(string.Empty),
-                show.ShowMetadata.HeadOrNone().Map(m => GetFanArt(m, maybeJellyfin, maybeEmby)).IfNone(string.Empty),
-                show.ShowMetadata.HeadOrNone().Map(m => m.Genres.Map(g => g.Name).ToList()).IfNone(new List<string>()),
-                show.ShowMetadata.HeadOrNone().Map(m => m.Tags.Map(g => g.Name).ToList()).IfNone(new List<string>()),
-                show.ShowMetadata.HeadOrNone().Map(m => m.Studios.Map(s => s.Name).ToList())
-                    .IfNone(new List<string>()),
-                show.ShowMetadata.HeadOrNone()
-                    .Map(
-                        m => (m.ContentRating ?? string.Empty).Split("/").Map(s => s.Trim())
-                            .Where(x => !string.IsNullOrWhiteSpace(x)).ToList()).IfNone(new List<string>()),
-                LanguagesForShow(languages),
-                show.ShowMetadata.HeadOrNone()
-                    .Map(
-                        m => m.Actors.OrderBy(a => a.Order).ThenBy(a => a.Id)
-                            .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin, maybeEmby))
-                            .ToList())
-                    .IfNone(new List<ActorCardViewModel>()));
-
-        internal static TelevisionSeasonViewModel ProjectToViewModel(
-            Season season,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby) =>
-            new(
-                season.Id,
-                season.ShowId,
-                season.Show.ShowMetadata.HeadOrNone().Map(m => m.Title ?? string.Empty).IfNone(string.Empty),
-                season.Show.ShowMetadata.HeadOrNone().Map(m => m.Year?.ToString() ?? string.Empty).IfNone(string.Empty),
-                season.SeasonNumber == 0 ? "Specials" : $"Season {season.SeasonNumber}",
-                season.SeasonMetadata.HeadOrNone().Map(m => GetPoster(m, maybeJellyfin, maybeEmby))
-                    .IfNone(string.Empty),
-                season.Show.ShowMetadata.HeadOrNone().Map(m => GetFanArt(m, maybeJellyfin, maybeEmby))
-                    .IfNone(string.Empty));
-
-        private static string GetPoster(
-            Metadata metadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby) =>
-            GetArtwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby);
-
-        private static string GetFanArt(
-            Metadata metadata,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby) =>
-            GetArtwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby);
-
-        private static string GetArtwork(
-            Metadata metadata,
-            ArtworkKind artworkKind,
-            Option<JellyfinMediaSource> maybeJellyfin,
-            Option<EmbyMediaSource> maybeEmby)
-        {
-            string artwork = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
-                .Match(a => a.Path, string.Empty);
-
-            if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
-            {
-                Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
-                if (artworkKind == ArtworkKind.Poster)
-                {
-                    url.SetQueryParam("fillHeight", 440);
-                }
-
-                artwork = url;
-            }
-            else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
-            {
-                Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
-                if (artworkKind == ArtworkKind.Poster)
-                {
-                    url.SetQueryParam("maxHeight", 440);
-                }
-
-                artwork = url;
-            }
-
-            return artwork;
-        }
-
-        private static List<CultureInfo> LanguagesForShow(List<string> languages)
-        {
-            CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
-
-            return languages
-                .Distinct()
+    internal static TelevisionShowViewModel ProjectToViewModel(
+        Show show,
+        List<string> languages,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby) =>
+        new(
+            show.Id,
+            show.ShowMetadata.HeadOrNone().Map(m => m.Title ?? string.Empty).IfNone(string.Empty),
+            show.ShowMetadata.HeadOrNone().Map(m => m.Year?.ToString() ?? string.Empty).IfNone(string.Empty),
+            show.ShowMetadata.HeadOrNone().Map(m => m.Plot ?? string.Empty).IfNone(string.Empty),
+            show.ShowMetadata.HeadOrNone().Map(m => GetPoster(m, maybeJellyfin, maybeEmby)).IfNone(string.Empty),
+            show.ShowMetadata.HeadOrNone().Map(m => GetFanArt(m, maybeJellyfin, maybeEmby)).IfNone(string.Empty),
+            show.ShowMetadata.HeadOrNone().Map(m => m.Genres.Map(g => g.Name).ToList()).IfNone(new List<string>()),
+            show.ShowMetadata.HeadOrNone().Map(m => m.Tags.Map(g => g.Name).ToList()).IfNone(new List<string>()),
+            show.ShowMetadata.HeadOrNone().Map(m => m.Studios.Map(s => s.Name).ToList())
+                .IfNone(new List<string>()),
+            show.ShowMetadata.HeadOrNone()
                 .Map(
-                    lang => allCultures.Filter(
-                        ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
-                .Sequence()
-                .Flatten()
-                .ToList();
+                    m => (m.ContentRating ?? string.Empty).Split("/").Map(s => s.Trim())
+                        .Where(x => !string.IsNullOrWhiteSpace(x)).ToList()).IfNone(new List<string>()),
+            LanguagesForShow(languages),
+            show.ShowMetadata.HeadOrNone()
+                .Map(
+                    m => m.Actors.OrderBy(a => a.Order).ThenBy(a => a.Id)
+                        .Map(a => MediaCards.Mapper.ProjectToViewModel(a, maybeJellyfin, maybeEmby))
+                        .ToList())
+                .IfNone(new List<ActorCardViewModel>()));
+
+    internal static TelevisionSeasonViewModel ProjectToViewModel(
+        Season season,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby) =>
+        new(
+            season.Id,
+            season.ShowId,
+            season.Show.ShowMetadata.HeadOrNone().Map(m => m.Title ?? string.Empty).IfNone(string.Empty),
+            season.Show.ShowMetadata.HeadOrNone().Map(m => m.Year?.ToString() ?? string.Empty).IfNone(string.Empty),
+            season.SeasonNumber == 0 ? "Specials" : $"Season {season.SeasonNumber}",
+            season.SeasonMetadata.HeadOrNone().Map(m => GetPoster(m, maybeJellyfin, maybeEmby))
+                .IfNone(string.Empty),
+            season.Show.ShowMetadata.HeadOrNone().Map(m => GetFanArt(m, maybeJellyfin, maybeEmby))
+                .IfNone(string.Empty));
+
+    private static string GetPoster(
+        Metadata metadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby) =>
+        GetArtwork(metadata, ArtworkKind.Poster, maybeJellyfin, maybeEmby);
+
+    private static string GetFanArt(
+        Metadata metadata,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby) =>
+        GetArtwork(metadata, ArtworkKind.FanArt, maybeJellyfin, maybeEmby);
+
+    private static string GetArtwork(
+        Metadata metadata,
+        ArtworkKind artworkKind,
+        Option<JellyfinMediaSource> maybeJellyfin,
+        Option<EmbyMediaSource> maybeEmby)
+    {
+        string artwork = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind))
+            .Match(a => a.Path, string.Empty);
+
+        if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
+        {
+            Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
+            if (artworkKind == ArtworkKind.Poster)
+            {
+                url.SetQueryParam("fillHeight", 440);
+            }
+
+            artwork = url;
         }
+        else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
+        {
+            Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
+            if (artworkKind == ArtworkKind.Poster)
+            {
+                url.SetQueryParam("maxHeight", 440);
+            }
+
+            artwork = url;
+        }
+
+        return artwork;
     }
-}
+
+    private static List<CultureInfo> LanguagesForShow(List<string> languages)
+    {
+        CultureInfo[] allCultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
+
+        return languages
+            .Distinct()
+            .Map(
+                lang => allCultures.Filter(
+                    ci => string.Equals(ci.ThreeLetterISOLanguageName, lang, StringComparison.OrdinalIgnoreCase)))
+            .Sequence()
+            .Flatten()
+            .ToList();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Queries/GetAllTelevisionSeasons.cs b/ErsatzTV.Application/Television/Queries/GetAllTelevisionSeasons.cs
index 07b5940d7..176af750b 100644
--- a/ErsatzTV.Application/Television/Queries/GetAllTelevisionSeasons.cs
+++ b/ErsatzTV.Application/Television/Queries/GetAllTelevisionSeasons.cs
@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using ErsatzTV.Application.MediaItems;
-using MediatR;
+using ErsatzTV.Application.MediaItems;
 
-namespace ErsatzTV.Application.Television.Queries
-{
-    public record GetAllTelevisionSeasons : IRequest<List<NamedMediaItemViewModel>>;
-}
+namespace ErsatzTV.Application.Television;
+
+public record GetAllTelevisionSeasons : IRequest<List<NamedMediaItemViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Queries/GetAllTelevisionSeasonsHandler.cs b/ErsatzTV.Application/Television/Queries/GetAllTelevisionSeasonsHandler.cs
index 8f490ec8f..3ab340fb4 100644
--- a/ErsatzTV.Application/Television/Queries/GetAllTelevisionSeasonsHandler.cs
+++ b/ErsatzTV.Application/Television/Queries/GetAllTelevisionSeasonsHandler.cs
@@ -1,26 +1,19 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaItems.Mapper;
 
-namespace ErsatzTV.Application.Television.Queries
+namespace ErsatzTV.Application.Television;
+
+public class
+    GetAllTelevisionSeasonsHandler : IRequestHandler<GetAllTelevisionSeasons, List<NamedMediaItemViewModel>>
 {
-    public class
-        GetAllTelevisionSeasonsHandler : IRequestHandler<GetAllTelevisionSeasons, List<NamedMediaItemViewModel>>
-    {
-        private readonly ITelevisionRepository _televisionRepository;
+    private readonly ITelevisionRepository _televisionRepository;
 
-        public GetAllTelevisionSeasonsHandler(ITelevisionRepository televisionRepository) =>
-            _televisionRepository = televisionRepository;
+    public GetAllTelevisionSeasonsHandler(ITelevisionRepository televisionRepository) =>
+        _televisionRepository = televisionRepository;
 
-        public Task<List<NamedMediaItemViewModel>> Handle(
-            GetAllTelevisionSeasons request,
-            CancellationToken cancellationToken) =>
-            _televisionRepository.GetAllSeasons().Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<NamedMediaItemViewModel>> Handle(
+        GetAllTelevisionSeasons request,
+        CancellationToken cancellationToken) =>
+        _televisionRepository.GetAllSeasons().Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Queries/GetAllTelevisionShows.cs b/ErsatzTV.Application/Television/Queries/GetAllTelevisionShows.cs
index aac8e200f..d0df92d3a 100644
--- a/ErsatzTV.Application/Television/Queries/GetAllTelevisionShows.cs
+++ b/ErsatzTV.Application/Television/Queries/GetAllTelevisionShows.cs
@@ -1,8 +1,5 @@
-using System.Collections.Generic;
-using ErsatzTV.Application.MediaItems;
-using MediatR;
+using ErsatzTV.Application.MediaItems;
 
-namespace ErsatzTV.Application.Television.Queries
-{
-    public record GetAllTelevisionShows : IRequest<List<NamedMediaItemViewModel>>;
-}
+namespace ErsatzTV.Application.Television;
+
+public record GetAllTelevisionShows : IRequest<List<NamedMediaItemViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Queries/GetAllTelevisionShowsHandler.cs b/ErsatzTV.Application/Television/Queries/GetAllTelevisionShowsHandler.cs
index 608befc30..7d673d5eb 100644
--- a/ErsatzTV.Application/Television/Queries/GetAllTelevisionShowsHandler.cs
+++ b/ErsatzTV.Application/Television/Queries/GetAllTelevisionShowsHandler.cs
@@ -1,25 +1,18 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaItems;
+using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.MediaItems.Mapper;
 
-namespace ErsatzTV.Application.Television.Queries
+namespace ErsatzTV.Application.Television;
+
+public class GetAllTelevisionShowsHandler : IRequestHandler<GetAllTelevisionShows, List<NamedMediaItemViewModel>>
 {
-    public class GetAllTelevisionShowsHandler : IRequestHandler<GetAllTelevisionShows, List<NamedMediaItemViewModel>>
-    {
-        private readonly ITelevisionRepository _televisionRepository;
+    private readonly ITelevisionRepository _televisionRepository;
 
-        public GetAllTelevisionShowsHandler(ITelevisionRepository televisionRepository) =>
-            _televisionRepository = televisionRepository;
+    public GetAllTelevisionShowsHandler(ITelevisionRepository televisionRepository) =>
+        _televisionRepository = televisionRepository;
 
-        public Task<List<NamedMediaItemViewModel>> Handle(
-            GetAllTelevisionShows request,
-            CancellationToken cancellationToken) =>
-            _televisionRepository.GetAllShows().Map(list => list.Map(ProjectToViewModel).ToList());
-    }
-}
+    public Task<List<NamedMediaItemViewModel>> Handle(
+        GetAllTelevisionShows request,
+        CancellationToken cancellationToken) =>
+        _televisionRepository.GetAllShows().Map(list => list.Map(ProjectToViewModel).ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Queries/GetTelevisionSeasonById.cs b/ErsatzTV.Application/Television/Queries/GetTelevisionSeasonById.cs
index e551e2168..c0177958f 100644
--- a/ErsatzTV.Application/Television/Queries/GetTelevisionSeasonById.cs
+++ b/ErsatzTV.Application/Television/Queries/GetTelevisionSeasonById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Television;
 
-namespace ErsatzTV.Application.Television.Queries
-{
-    public record GetTelevisionSeasonById(int SeasonId) : IRequest<Option<TelevisionSeasonViewModel>>;
-}
+public record GetTelevisionSeasonById(int SeasonId) : IRequest<Option<TelevisionSeasonViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Queries/GetTelevisionSeasonByIdHandler.cs b/ErsatzTV.Application/Television/Queries/GetTelevisionSeasonByIdHandler.cs
index efac5ff28..de2ce9e43 100644
--- a/ErsatzTV.Application/Television/Queries/GetTelevisionSeasonByIdHandler.cs
+++ b/ErsatzTV.Application/Television/Queries/GetTelevisionSeasonByIdHandler.cs
@@ -1,39 +1,34 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.Television.Mapper;
 
-namespace ErsatzTV.Application.Television.Queries
+namespace ErsatzTV.Application.Television;
+
+public class
+    GetTelevisionSeasonByIdHandler : IRequestHandler<GetTelevisionSeasonById, Option<TelevisionSeasonViewModel>>
 {
-    public class
-        GetTelevisionSeasonByIdHandler : IRequestHandler<GetTelevisionSeasonById, Option<TelevisionSeasonViewModel>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public GetTelevisionSeasonByIdHandler(
+        ITelevisionRepository televisionRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public GetTelevisionSeasonByIdHandler(
-            ITelevisionRepository televisionRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _televisionRepository = televisionRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<Option<TelevisionSeasonViewModel>> Handle(
-            GetTelevisionSeasonById request,
-            CancellationToken cancellationToken)
-        {
-            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                .Map(list => list.HeadOrNone());
-
-            Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                .Map(list => list.HeadOrNone());
-
-            return await _televisionRepository.GetSeason(request.SeasonId)
-                .MapT(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby));
-        }
+        _televisionRepository = televisionRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<Option<TelevisionSeasonViewModel>> Handle(
+        GetTelevisionSeasonById request,
+        CancellationToken cancellationToken)
+    {
+        Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+            .Map(list => list.HeadOrNone());
+
+        Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+            .Map(list => list.HeadOrNone());
+
+        return await _televisionRepository.GetSeason(request.SeasonId)
+            .MapT(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Queries/GetTelevisionShowById.cs b/ErsatzTV.Application/Television/Queries/GetTelevisionShowById.cs
index 5d640f391..cc4e6c62a 100644
--- a/ErsatzTV.Application/Television/Queries/GetTelevisionShowById.cs
+++ b/ErsatzTV.Application/Television/Queries/GetTelevisionShowById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Television;
 
-namespace ErsatzTV.Application.Television.Queries
-{
-    public record GetTelevisionShowById(int Id) : IRequest<Option<TelevisionShowViewModel>>;
-}
+public record GetTelevisionShowById(int Id) : IRequest<Option<TelevisionShowViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/Queries/GetTelevisionShowByIdHandler.cs b/ErsatzTV.Application/Television/Queries/GetTelevisionShowByIdHandler.cs
index fce7c3c3e..527b4f8d7 100644
--- a/ErsatzTV.Application/Television/Queries/GetTelevisionShowByIdHandler.cs
+++ b/ErsatzTV.Application/Television/Queries/GetTelevisionShowByIdHandler.cs
@@ -1,49 +1,43 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using MediatR;
 using static ErsatzTV.Application.Television.Mapper;
 
-namespace ErsatzTV.Application.Television.Queries
+namespace ErsatzTV.Application.Television;
+
+public class GetTelevisionShowByIdHandler : IRequestHandler<GetTelevisionShowById, Option<TelevisionShowViewModel>>
 {
-    public class GetTelevisionShowByIdHandler : IRequestHandler<GetTelevisionShowById, Option<TelevisionShowViewModel>>
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly ISearchRepository _searchRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public GetTelevisionShowByIdHandler(
+        ITelevisionRepository televisionRepository,
+        ISearchRepository searchRepository,
+        IMediaSourceRepository mediaSourceRepository)
     {
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly ISearchRepository _searchRepository;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public GetTelevisionShowByIdHandler(
-            ITelevisionRepository televisionRepository,
-            ISearchRepository searchRepository,
-            IMediaSourceRepository mediaSourceRepository)
-        {
-            _televisionRepository = televisionRepository;
-            _searchRepository = searchRepository;
-            _mediaSourceRepository = mediaSourceRepository;
-        }
-
-        public async Task<Option<TelevisionShowViewModel>> Handle(
-            GetTelevisionShowById request,
-            CancellationToken cancellationToken)
-        {
-            Option<Show> maybeShow = await _televisionRepository.GetShow(request.Id);
-            return await maybeShow.Match<Task<Option<TelevisionShowViewModel>>>(
-                async show =>
-                {
-                    Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
-                        .Map(list => list.HeadOrNone());
-
-                    Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
-                        .Map(list => list.HeadOrNone());
-
-                    List<string> mediaCodes = await _searchRepository.GetLanguagesForShow(show);
-                    List<string> languageCodes = await _searchRepository.GetAllLanguageCodes(mediaCodes);
-                    return ProjectToViewModel(show, languageCodes, maybeJellyfin, maybeEmby);
-                },
-                () => Task.FromResult(Option<TelevisionShowViewModel>.None));
-        }
+        _televisionRepository = televisionRepository;
+        _searchRepository = searchRepository;
+        _mediaSourceRepository = mediaSourceRepository;
     }
-}
+
+    public async Task<Option<TelevisionShowViewModel>> Handle(
+        GetTelevisionShowById request,
+        CancellationToken cancellationToken)
+    {
+        Option<Show> maybeShow = await _televisionRepository.GetShow(request.Id);
+        return await maybeShow.Match<Task<Option<TelevisionShowViewModel>>>(
+            async show =>
+            {
+                Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
+                    .Map(list => list.HeadOrNone());
+
+                Option<EmbyMediaSource> maybeEmby = await _mediaSourceRepository.GetAllEmby()
+                    .Map(list => list.HeadOrNone());
+
+                List<string> mediaCodes = await _searchRepository.GetLanguagesForShow(show);
+                List<string> languageCodes = await _searchRepository.GetAllLanguageCodes(mediaCodes);
+                return ProjectToViewModel(show, languageCodes, maybeJellyfin, maybeEmby);
+            },
+            () => Task.FromResult(Option<TelevisionShowViewModel>.None));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/TelevisionSeasonViewModel.cs b/ErsatzTV.Application/Television/TelevisionSeasonViewModel.cs
index 3bfd651b0..6d9d637f7 100644
--- a/ErsatzTV.Application/Television/TelevisionSeasonViewModel.cs
+++ b/ErsatzTV.Application/Television/TelevisionSeasonViewModel.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Application.Television
-{
-    public record TelevisionSeasonViewModel(
-        int Id,
-        int ShowId,
-        string Title,
-        string Year,
-        string Name,
-        string Poster,
-        string FanArt);
-}
+namespace ErsatzTV.Application.Television;
+
+public record TelevisionSeasonViewModel(
+    int Id,
+    int ShowId,
+    string Title,
+    string Year,
+    string Name,
+    string Poster,
+    string FanArt);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Television/TelevisionShowViewModel.cs b/ErsatzTV.Application/Television/TelevisionShowViewModel.cs
index a22329aaa..c351133aa 100644
--- a/ErsatzTV.Application/Television/TelevisionShowViewModel.cs
+++ b/ErsatzTV.Application/Television/TelevisionShowViewModel.cs
@@ -1,20 +1,18 @@
-using System.Collections.Generic;
-using System.Globalization;
+using System.Globalization;
 using ErsatzTV.Application.MediaCards;
 
-namespace ErsatzTV.Application.Television
-{
-    public record TelevisionShowViewModel(
-        int Id,
-        string Title,
-        string Year,
-        string Plot,
-        string Poster,
-        string FanArt,
-        List<string> Genres,
-        List<string> Tags,
-        List<string> Studios,
-        List<string> ContentRatings,
-        List<CultureInfo> Languages,
-        List<ActorCardViewModel> Actors);
-}
+namespace ErsatzTV.Application.Television;
+
+public record TelevisionShowViewModel(
+    int Id,
+    string Title,
+    string Year,
+    string Plot,
+    string Poster,
+    string FanArt,
+    List<string> Genres,
+    List<string> Tags,
+    List<string> Studios,
+    List<string> ContentRatings,
+    List<CultureInfo> Languages,
+    List<ActorCardViewModel> Actors);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Validators/GetMemberName.cs b/ErsatzTV.Application/Validators/GetMemberName.cs
index a57fbf8d0..25fb11498 100644
--- a/ErsatzTV.Application/Validators/GetMemberName.cs
+++ b/ErsatzTV.Application/Validators/GetMemberName.cs
@@ -1,20 +1,18 @@
-using System;
-using System.Linq.Expressions;
+using System.Linq.Expressions;
 using System.Reflection;
 
-namespace ErsatzTV
-{
-    public static partial class Validators
-    {
-        private static string GetMemberName<T, T2>(Expression<Func<T, T2>> expression)
-        {
-            var member = expression.Body as MemberExpression;
-            if (member?.Member is PropertyInfo propertyInfo)
-            {
-                return propertyInfo.Name;
-            }
+namespace ErsatzTV;
 
-            throw new ArgumentException("Expression is not a property");
+public static partial class Validators
+{
+    private static string GetMemberName<T, T2>(Expression<Func<T, T2>> expression)
+    {
+        var member = expression.Body as MemberExpression;
+        if (member?.Member is PropertyInfo propertyInfo)
+        {
+            return propertyInfo.Name;
         }
+
+        throw new ArgumentException("Expression is not a property");
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Validators/NumericValidation.cs b/ErsatzTV.Application/Validators/NumericValidation.cs
index 4bdd8b043..377c8c28d 100644
--- a/ErsatzTV.Application/Validators/NumericValidation.cs
+++ b/ErsatzTV.Application/Validators/NumericValidation.cs
@@ -1,19 +1,15 @@
-using System;
-using System.Linq.Expressions;
+using System.Linq.Expressions;
 using ErsatzTV.Core;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV
+namespace ErsatzTV;
+
+public static partial class Validators
 {
-    public static partial class Validators
-    {
-        public static Func<Expression<Func<T, int>>, Validation<BaseError, int>>
-            AtLeast<T>(this T input, int minimum) =>
-            value => Optional(value)
-                .Map(i => i.Compile()(input))
-                .Where(i => i >= minimum)
-                .ToValidation<BaseError>(
-                    $"[{GetMemberName(value)}] must be greater or equal to {minimum}");
-    }
-}
+    public static Func<Expression<Func<T, int>>, Validation<BaseError, int>>
+        AtLeast<T>(this T input, int minimum) =>
+        value => Optional(value)
+            .Map(i => i.Compile()(input))
+            .Where(i => i >= minimum)
+            .ToValidation<BaseError>(
+                $"[{GetMemberName(value)}] must be greater or equal to {minimum}");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Validators/StringValidation.cs b/ErsatzTV.Application/Validators/StringValidation.cs
index 2d4f8fcb8..12a749b60 100644
--- a/ErsatzTV.Application/Validators/StringValidation.cs
+++ b/ErsatzTV.Application/Validators/StringValidation.cs
@@ -1,24 +1,20 @@
-using System;
-using System.Linq.Expressions;
+using System.Linq.Expressions;
 using ErsatzTV.Core;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV
+namespace ErsatzTV;
+
+public static partial class Validators
 {
-    public static partial class Validators
-    {
-        public static Func<Expression<Func<T, string>>, Validation<BaseError, string>> NotLongerThan<T>(
-            this T input,
-            int maxLength) =>
-            expression => Optional(expression)
-                .Map(exp => exp.Compile()(input))
-                .Where(s => s.Length <= maxLength)
-                .ToValidation<BaseError>($"[{GetMemberName(expression)}] must not be longer than {maxLength}");
+    public static Func<Expression<Func<T, string>>, Validation<BaseError, string>> NotLongerThan<T>(
+        this T input,
+        int maxLength) =>
+        expression => Optional(expression)
+            .Map(exp => exp.Compile()(input))
+            .Where(s => s.Length <= maxLength)
+            .ToValidation<BaseError>($"[{GetMemberName(expression)}] must not be longer than {maxLength}");
 
-        public static Validation<BaseError, string> NotEmpty<T>(this T input, Expression<Func<T, string>> expression) =>
-            Optional(expression.Compile()(input))
-                .Where(s => !string.IsNullOrWhiteSpace(s))
-                .ToValidation<BaseError>($"[{GetMemberName(expression)}] is an empty string");
-    }
-}
+    public static Validation<BaseError, string> NotEmpty<T>(this T input, Expression<Func<T, string>> expression) =>
+        Optional(expression.Compile()(input))
+            .Where(s => !string.IsNullOrWhiteSpace(s))
+            .ToValidation<BaseError>($"[{GetMemberName(expression)}] is an empty string");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Commands/CopyWatermark.cs b/ErsatzTV.Application/Watermarks/Commands/CopyWatermark.cs
index 831992032..33ff57d8e 100644
--- a/ErsatzTV.Application/Watermarks/Commands/CopyWatermark.cs
+++ b/ErsatzTV.Application/Watermarks/Commands/CopyWatermark.cs
@@ -1,9 +1,6 @@
 using ErsatzTV.Core;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Watermarks.Commands
-{
-    public record CopyWatermark
-        (int WatermarkId, string Name) : IRequest<Either<BaseError, WatermarkViewModel>>;
-}
+namespace ErsatzTV.Application.Watermarks;
+
+public record CopyWatermark
+    (int WatermarkId, string Name) : IRequest<Either<BaseError, WatermarkViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Commands/CopyWatermarkHandler.cs b/ErsatzTV.Application/Watermarks/Commands/CopyWatermarkHandler.cs
index ecf8d2114..9e6882028 100644
--- a/ErsatzTV.Application/Watermarks/Commands/CopyWatermarkHandler.cs
+++ b/ErsatzTV.Application/Watermarks/Commands/CopyWatermarkHandler.cs
@@ -1,54 +1,49 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.ChangeTracking;
 using static ErsatzTV.Application.Watermarks.Mapper;
 
-namespace ErsatzTV.Application.Watermarks.Commands
+namespace ErsatzTV.Application.Watermarks;
+
+public class CopyWatermarkHandler :
+    IRequestHandler<CopyWatermark, Either<BaseError, WatermarkViewModel>>
 {
-    public class CopyWatermarkHandler :
-        IRequestHandler<CopyWatermark, Either<BaseError, WatermarkViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CopyWatermarkHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public Task<Either<BaseError, WatermarkViewModel>> Handle(
+        CopyWatermark request,
+        CancellationToken cancellationToken) =>
+        Validate(request)
+            .MapT(PerformCopy)
+            .Bind(v => v.ToEitherAsync());
+
+    private async Task<WatermarkViewModel> PerformCopy(CopyWatermark request)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        ChannelWatermark channelWatermark = await dbContext.ChannelWatermarks.FindAsync(request.WatermarkId);
 
-        public CopyWatermarkHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        PropertyValues values = dbContext.Entry(channelWatermark).CurrentValues.Clone();
+        values["Id"] = 0;
 
-        public Task<Either<BaseError, WatermarkViewModel>> Handle(
-            CopyWatermark request,
-            CancellationToken cancellationToken) =>
-            Validate(request)
-                .MapT(PerformCopy)
-                .Bind(v => v.ToEitherAsync());
+        var clone = new ChannelWatermark();
+        await dbContext.AddAsync(clone);
+        dbContext.Entry(clone).CurrentValues.SetValues(values);
+        clone.Name = request.Name;
 
-        private async Task<WatermarkViewModel> PerformCopy(CopyWatermark request)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            ChannelWatermark channelWatermark = await dbContext.ChannelWatermarks.FindAsync(request.WatermarkId);
+        await dbContext.SaveChangesAsync();
 
-            PropertyValues values = dbContext.Entry(channelWatermark).CurrentValues.Clone();
-            values["Id"] = 0;
-
-            var clone = new ChannelWatermark();
-            await dbContext.AddAsync(clone);
-            dbContext.Entry(clone).CurrentValues.SetValues(values);
-            clone.Name = request.Name;
-
-            await dbContext.SaveChangesAsync();
-
-            return ProjectToViewModel(clone);
-        }
-
-        private static Task<Validation<BaseError, CopyWatermark>> Validate(CopyWatermark request) =>
-            ValidateName(request).AsTask().MapT(_ => request);
-
-        private static Validation<BaseError, string> ValidateName(CopyWatermark request) =>
-            request.NotEmpty(x => x.Name)
-                .Bind(_ => request.NotLongerThan(50)(x => x.Name));
+        return ProjectToViewModel(clone);
     }
-}
+
+    private static Task<Validation<BaseError, CopyWatermark>> Validate(CopyWatermark request) =>
+        ValidateName(request).AsTask().MapT(_ => request);
+
+    private static Validation<BaseError, string> ValidateName(CopyWatermark request) =>
+        request.NotEmpty(x => x.Name)
+            .Bind(_ => request.NotLongerThan(50)(x => x.Name));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Commands/CreateWatermark.cs b/ErsatzTV.Application/Watermarks/Commands/CreateWatermark.cs
index edb34f3ac..73351e27e 100644
--- a/ErsatzTV.Application/Watermarks/Commands/CreateWatermark.cs
+++ b/ErsatzTV.Application/Watermarks/Commands/CreateWatermark.cs
@@ -1,24 +1,21 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Watermarks.Commands
-{
-    public record CreateWatermark(
-        string Name,
-        string Image,
-        ChannelWatermarkMode Mode,
-        ChannelWatermarkImageSource ImageSource,
-        WatermarkLocation Location,
-        WatermarkSize Size,
-        int Width,
-        int HorizontalMargin,
-        int VerticalMargin,
-        int FrequencyMinutes,
-        int DurationSeconds,
-        int Opacity) : IRequest<Either<BaseError, CreateWatermarkResult>>;
+namespace ErsatzTV.Application.Watermarks;
 
-    public record CreateWatermarkResult(int WatermarkId) : EntityIdResult(WatermarkId);
-}
+public record CreateWatermark(
+    string Name,
+    string Image,
+    ChannelWatermarkMode Mode,
+    ChannelWatermarkImageSource ImageSource,
+    WatermarkLocation Location,
+    WatermarkSize Size,
+    int Width,
+    int HorizontalMargin,
+    int VerticalMargin,
+    int FrequencyMinutes,
+    int DurationSeconds,
+    int Opacity) : IRequest<Either<BaseError, CreateWatermarkResult>>;
+
+public record CreateWatermarkResult(int WatermarkId) : EntityIdResult(WatermarkId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Commands/CreateWatermarkHandler.cs b/ErsatzTV.Application/Watermarks/Commands/CreateWatermarkHandler.cs
index 595325e3c..16374483a 100644
--- a/ErsatzTV.Application/Watermarks/Commands/CreateWatermarkHandler.cs
+++ b/ErsatzTV.Application/Watermarks/Commands/CreateWatermarkHandler.cs
@@ -1,60 +1,55 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.Watermarks.Commands
+namespace ErsatzTV.Application.Watermarks;
+
+public class CreateWatermarkHandler : IRequestHandler<CreateWatermark, Either<BaseError, CreateWatermarkResult>>
 {
-    public class CreateWatermarkHandler : IRequestHandler<CreateWatermark, Either<BaseError, CreateWatermarkResult>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public CreateWatermarkHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, CreateWatermarkResult>> Handle(
+        CreateWatermark request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public CreateWatermarkHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, CreateWatermarkResult>> Handle(
-            CreateWatermark request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, ChannelWatermark> validation = Validate(request);
-            return await validation.Apply(profile => PersistChannelWatermark(dbContext, profile));
-        }
-
-        private static async Task<CreateWatermarkResult> PersistChannelWatermark(
-            TvContext dbContext,
-            ChannelWatermark watermark)
-        {
-            await dbContext.ChannelWatermarks.AddAsync(watermark);
-            await dbContext.SaveChangesAsync();
-            return new CreateWatermarkResult(watermark.Id);
-        }
-
-        private static Validation<BaseError, ChannelWatermark> Validate(CreateWatermark request) =>
-            ValidateName(request)
-                .Map(
-                    _ => new ChannelWatermark
-                    {
-                        Name = request.Name,
-                        Image = request.ImageSource == ChannelWatermarkImageSource.Custom ? request.Image : null,
-                        Mode = request.Mode,
-                        ImageSource = request.ImageSource,
-                        Location = request.Location,
-                        Size = request.Size,
-                        WidthPercent = request.Width,
-                        HorizontalMarginPercent = request.HorizontalMargin,
-                        VerticalMarginPercent = request.VerticalMargin,
-                        FrequencyMinutes = request.FrequencyMinutes,
-                        DurationSeconds = request.DurationSeconds,
-                        Opacity = request.Opacity
-                    });
-
-        private static Validation<BaseError, string> ValidateName(CreateWatermark request) =>
-            request.NotEmpty(x => x.Name)
-                .Bind(_ => request.NotLongerThan(50)(x => x.Name));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, ChannelWatermark> validation = Validate(request);
+        return await LanguageExtensions.Apply(validation, profile => PersistChannelWatermark(dbContext, profile));
     }
-}
+
+    private static async Task<CreateWatermarkResult> PersistChannelWatermark(
+        TvContext dbContext,
+        ChannelWatermark watermark)
+    {
+        await dbContext.ChannelWatermarks.AddAsync(watermark);
+        await dbContext.SaveChangesAsync();
+        return new CreateWatermarkResult(watermark.Id);
+    }
+
+    private static Validation<BaseError, ChannelWatermark> Validate(CreateWatermark request) =>
+        ValidateName(request)
+            .Map(
+                _ => new ChannelWatermark
+                {
+                    Name = request.Name,
+                    Image = request.ImageSource == ChannelWatermarkImageSource.Custom ? request.Image : null,
+                    Mode = request.Mode,
+                    ImageSource = request.ImageSource,
+                    Location = request.Location,
+                    Size = request.Size,
+                    WidthPercent = request.Width,
+                    HorizontalMarginPercent = request.HorizontalMargin,
+                    VerticalMarginPercent = request.VerticalMargin,
+                    FrequencyMinutes = request.FrequencyMinutes,
+                    DurationSeconds = request.DurationSeconds,
+                    Opacity = request.Opacity
+                });
+
+    private static Validation<BaseError, string> ValidateName(CreateWatermark request) =>
+        request.NotEmpty(x => x.Name)
+            .Bind(_ => request.NotLongerThan(50)(x => x.Name));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Commands/DeleteWatermark.cs b/ErsatzTV.Application/Watermarks/Commands/DeleteWatermark.cs
index 65e684181..52cee8686 100644
--- a/ErsatzTV.Application/Watermarks/Commands/DeleteWatermark.cs
+++ b/ErsatzTV.Application/Watermarks/Commands/DeleteWatermark.cs
@@ -1,7 +1,5 @@
 using ErsatzTV.Core;
-using LanguageExt;
 
-namespace ErsatzTV.Application.Watermarks.Commands
-{
-    public record DeleteWatermark(int WatermarkId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}
+namespace ErsatzTV.Application.Watermarks;
+
+public record DeleteWatermark(int WatermarkId) : MediatR.IRequest<Either<BaseError, Unit>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Commands/DeleteWatermarkHandler.cs b/ErsatzTV.Application/Watermarks/Commands/DeleteWatermarkHandler.cs
index 17c58d2e7..3dd3b68fb 100644
--- a/ErsatzTV.Application/Watermarks/Commands/DeleteWatermarkHandler.cs
+++ b/ErsatzTV.Application/Watermarks/Commands/DeleteWatermarkHandler.cs
@@ -1,45 +1,40 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Application.Watermarks.Commands
+namespace ErsatzTV.Application.Watermarks;
+
+public class DeleteWatermarkHandler : MediatR.IRequestHandler<DeleteWatermark, Either<BaseError, Unit>>
 {
-    public class DeleteWatermarkHandler : MediatR.IRequestHandler<DeleteWatermark, Either<BaseError, Unit>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public DeleteWatermarkHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, Unit>> Handle(
+        DeleteWatermark request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public DeleteWatermarkHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, Unit>> Handle(
-            DeleteWatermark request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Validation<BaseError, ChannelWatermark> validation = await WatermarkMustExist(dbContext, request);
-            return await validation.Apply(p => DoDeletion(dbContext, p));
-        }
-
-        private static async Task<Unit> DoDeletion(TvContext dbContext, ChannelWatermark watermark)
-        {
-            await dbContext.Database.ExecuteSqlRawAsync(
-                $"UPDATE Channel SET WatermarkId = NULL WHERE WatermarkId = {watermark.Id}");
-            dbContext.ChannelWatermarks.Remove(watermark);
-            await dbContext.SaveChangesAsync();
-            return Unit.Default;
-        }
-
-        private static Task<Validation<BaseError, ChannelWatermark>> WatermarkMustExist(
-            TvContext dbContext,
-            DeleteWatermark request) =>
-            dbContext.ChannelWatermarks
-                .SelectOneAsync(p => p.Id, p => p.Id == request.WatermarkId)
-                .Map(o => o.ToValidation<BaseError>($"Watermark {request.WatermarkId} does not exist"));
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Validation<BaseError, ChannelWatermark> validation = await WatermarkMustExist(dbContext, request);
+        return await LanguageExtensions.Apply(validation, p => DoDeletion(dbContext, p));
     }
-}
+
+    private static async Task<Unit> DoDeletion(TvContext dbContext, ChannelWatermark watermark)
+    {
+        await dbContext.Database.ExecuteSqlRawAsync(
+            $"UPDATE Channel SET WatermarkId = NULL WHERE WatermarkId = {watermark.Id}");
+        dbContext.ChannelWatermarks.Remove(watermark);
+        await dbContext.SaveChangesAsync();
+        return Unit.Default;
+    }
+
+    private static Task<Validation<BaseError, ChannelWatermark>> WatermarkMustExist(
+        TvContext dbContext,
+        DeleteWatermark request) =>
+        dbContext.ChannelWatermarks
+            .SelectOneAsync(p => p.Id, p => p.Id == request.WatermarkId)
+            .Map(o => o.ToValidation<BaseError>($"Watermark {request.WatermarkId} does not exist"));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Commands/UpdateWatermark.cs b/ErsatzTV.Application/Watermarks/Commands/UpdateWatermark.cs
index 6ec1744c1..d9b3837a9 100644
--- a/ErsatzTV.Application/Watermarks/Commands/UpdateWatermark.cs
+++ b/ErsatzTV.Application/Watermarks/Commands/UpdateWatermark.cs
@@ -1,25 +1,22 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
-using MediatR;
 
-namespace ErsatzTV.Application.Watermarks.Commands
-{
-    public record UpdateWatermark(
-        int Id,
-        string Name,
-        string Image,
-        ChannelWatermarkMode Mode,
-        ChannelWatermarkImageSource ImageSource,
-        WatermarkLocation Location,
-        WatermarkSize Size,
-        int Width,
-        int HorizontalMargin,
-        int VerticalMargin,
-        int FrequencyMinutes,
-        int DurationSeconds,
-        int Opacity) : IRequest<Either<BaseError, UpdateWatermarkResult>>;
+namespace ErsatzTV.Application.Watermarks;
 
-    public record UpdateWatermarkResult(int WatermarkId) : EntityIdResult(WatermarkId);
-}
+public record UpdateWatermark(
+    int Id,
+    string Name,
+    string Image,
+    ChannelWatermarkMode Mode,
+    ChannelWatermarkImageSource ImageSource,
+    WatermarkLocation Location,
+    WatermarkSize Size,
+    int Width,
+    int HorizontalMargin,
+    int VerticalMargin,
+    int FrequencyMinutes,
+    int DurationSeconds,
+    int Opacity) : IRequest<Either<BaseError, UpdateWatermarkResult>>;
+
+public record UpdateWatermarkResult(int WatermarkId) : EntityIdResult(WatermarkId);
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Commands/UpdateWatermarkHandler.cs b/ErsatzTV.Application/Watermarks/Commands/UpdateWatermarkHandler.cs
index 15a75a1dc..de6c6fef7 100644
--- a/ErsatzTV.Application/Watermarks/Commands/UpdateWatermarkHandler.cs
+++ b/ErsatzTV.Application/Watermarks/Commands/UpdateWatermarkHandler.cs
@@ -1,67 +1,62 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Application.Watermarks.Commands
+namespace ErsatzTV.Application.Watermarks;
+
+public class UpdateWatermarkHandler : IRequestHandler<UpdateWatermark, Either<BaseError, UpdateWatermarkResult>>
 {
-    public class UpdateWatermarkHandler : IRequestHandler<UpdateWatermark, Either<BaseError, UpdateWatermarkResult>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public UpdateWatermarkHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Either<BaseError, UpdateWatermarkResult>> Handle(
+        UpdateWatermark request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public UpdateWatermarkHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Either<BaseError, UpdateWatermarkResult>> Handle(
-            UpdateWatermark request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-            Validation<BaseError, ChannelWatermark> validation = await Validate(dbContext, request);
-            return await validation.Apply(p => ApplyUpdateRequest(dbContext, p, request));
-        }
-
-        private static async Task<UpdateWatermarkResult> ApplyUpdateRequest(
-            TvContext dbContext,
-            ChannelWatermark p,
-            UpdateWatermark update)
-        {
-            p.Name = update.Name;
-            p.Image = update.ImageSource == ChannelWatermarkImageSource.Custom ? update.Image : null;
-            p.Mode = update.Mode;
-            p.ImageSource = update.ImageSource;
-            p.Location = update.Location;
-            p.Size = update.Size;
-            p.WidthPercent = update.Width;
-            p.HorizontalMarginPercent = update.HorizontalMargin;
-            p.VerticalMarginPercent = update.VerticalMargin;
-            p.FrequencyMinutes = update.FrequencyMinutes;
-            p.DurationSeconds = update.DurationSeconds;
-            p.Opacity = update.Opacity;
-            await dbContext.SaveChangesAsync();
-            return new UpdateWatermarkResult(p.Id);
-        }
-
-        private static async Task<Validation<BaseError, ChannelWatermark>> Validate(
-            TvContext dbContext,
-            UpdateWatermark request) =>
-            (await WatermarkMustExist(dbContext, request), ValidateName(request))
-            .Apply((watermark, _) => watermark);
-
-        private static Task<Validation<BaseError, ChannelWatermark>> WatermarkMustExist(
-            TvContext dbContext,
-            UpdateWatermark updateWatermark) =>
-            dbContext.ChannelWatermarks
-                .SelectOneAsync(p => p.Id, p => p.Id == updateWatermark.Id)
-                .Map(o => o.ToValidation<BaseError>("Watermark does not exist."));
-
-        private static Validation<BaseError, string> ValidateName(UpdateWatermark updateWatermark) =>
-            updateWatermark.NotEmpty(x => x.Name)
-                .Bind(_ => updateWatermark.NotLongerThan(50)(x => x.Name));
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+        Validation<BaseError, ChannelWatermark> validation = await Validate(dbContext, request);
+        return await LanguageExtensions.Apply(validation, p => ApplyUpdateRequest(dbContext, p, request));
     }
-}
+
+    private static async Task<UpdateWatermarkResult> ApplyUpdateRequest(
+        TvContext dbContext,
+        ChannelWatermark p,
+        UpdateWatermark update)
+    {
+        p.Name = update.Name;
+        p.Image = update.ImageSource == ChannelWatermarkImageSource.Custom ? update.Image : null;
+        p.Mode = update.Mode;
+        p.ImageSource = update.ImageSource;
+        p.Location = update.Location;
+        p.Size = update.Size;
+        p.WidthPercent = update.Width;
+        p.HorizontalMarginPercent = update.HorizontalMargin;
+        p.VerticalMarginPercent = update.VerticalMargin;
+        p.FrequencyMinutes = update.FrequencyMinutes;
+        p.DurationSeconds = update.DurationSeconds;
+        p.Opacity = update.Opacity;
+        await dbContext.SaveChangesAsync();
+        return new UpdateWatermarkResult(p.Id);
+    }
+
+    private static async Task<Validation<BaseError, ChannelWatermark>> Validate(
+        TvContext dbContext,
+        UpdateWatermark request) =>
+        (await WatermarkMustExist(dbContext, request), ValidateName(request))
+        .Apply((watermark, _) => watermark);
+
+    private static Task<Validation<BaseError, ChannelWatermark>> WatermarkMustExist(
+        TvContext dbContext,
+        UpdateWatermark updateWatermark) =>
+        dbContext.ChannelWatermarks
+            .SelectOneAsync(p => p.Id, p => p.Id == updateWatermark.Id)
+            .Map(o => o.ToValidation<BaseError>("Watermark does not exist."));
+
+    private static Validation<BaseError, string> ValidateName(UpdateWatermark updateWatermark) =>
+        updateWatermark.NotEmpty(x => x.Name)
+            .Bind(_ => updateWatermark.NotLongerThan(50)(x => x.Name));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Mapper.cs b/ErsatzTV.Application/Watermarks/Mapper.cs
index 360b72533..e59821416 100644
--- a/ErsatzTV.Application/Watermarks/Mapper.cs
+++ b/ErsatzTV.Application/Watermarks/Mapper.cs
@@ -1,23 +1,22 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Application.Watermarks
+namespace ErsatzTV.Application.Watermarks;
+
+internal static class Mapper
 {
-    internal static class Mapper
-    {
-        public static WatermarkViewModel ProjectToViewModel(ChannelWatermark watermark) =>
-            new(
-                watermark.Id,
-                watermark.Image,
-                watermark.Name,
-                watermark.Mode,
-                watermark.ImageSource,
-                watermark.Location,
-                watermark.Size,
-                watermark.WidthPercent,
-                watermark.HorizontalMarginPercent,
-                watermark.VerticalMarginPercent,
-                watermark.FrequencyMinutes,
-                watermark.DurationSeconds,
-                watermark.Opacity);
-    }
-}
+    public static WatermarkViewModel ProjectToViewModel(ChannelWatermark watermark) =>
+        new(
+            watermark.Id,
+            watermark.Image,
+            watermark.Name,
+            watermark.Mode,
+            watermark.ImageSource,
+            watermark.Location,
+            watermark.Size,
+            watermark.WidthPercent,
+            watermark.HorizontalMarginPercent,
+            watermark.VerticalMarginPercent,
+            watermark.FrequencyMinutes,
+            watermark.DurationSeconds,
+            watermark.Opacity);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Queries/GetAllWatermarks.cs b/ErsatzTV.Application/Watermarks/Queries/GetAllWatermarks.cs
index 0626d4a56..728d88610 100644
--- a/ErsatzTV.Application/Watermarks/Queries/GetAllWatermarks.cs
+++ b/ErsatzTV.Application/Watermarks/Queries/GetAllWatermarks.cs
@@ -1,7 +1,3 @@
-using System.Collections.Generic;
-using MediatR;
+namespace ErsatzTV.Application.Watermarks;
 
-namespace ErsatzTV.Application.Watermarks.Queries
-{
-    public record GetAllWatermarks : IRequest<List<WatermarkViewModel>>;
-}
+public record GetAllWatermarks : IRequest<List<WatermarkViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Queries/GetAllWatermarksHandler.cs b/ErsatzTV.Application/Watermarks/Queries/GetAllWatermarksHandler.cs
index 75c9cc40f..92910be44 100644
--- a/ErsatzTV.Application/Watermarks/Queries/GetAllWatermarksHandler.cs
+++ b/ErsatzTV.Application/Watermarks/Queries/GetAllWatermarksHandler.cs
@@ -1,30 +1,23 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
-using MediatR;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Watermarks.Mapper;
 
-namespace ErsatzTV.Application.Watermarks.Queries
+namespace ErsatzTV.Application.Watermarks;
+
+public class GetAllWatermarksHandler : IRequestHandler<GetAllWatermarks, List<WatermarkViewModel>>
 {
-    public class GetAllWatermarksHandler : IRequestHandler<GetAllWatermarks, List<WatermarkViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetAllWatermarksHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<List<WatermarkViewModel>> Handle(
+        GetAllWatermarks request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetAllWatermarksHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<List<WatermarkViewModel>> Handle(
-            GetAllWatermarks request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.ChannelWatermarks
-                .ToListAsync(cancellationToken)
-                .Map(list => list.Map(ProjectToViewModel).ToList());
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.ChannelWatermarks
+            .ToListAsync(cancellationToken)
+            .Map(list => list.Map(ProjectToViewModel).ToList());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Queries/GetWatermarkById.cs b/ErsatzTV.Application/Watermarks/Queries/GetWatermarkById.cs
index 356b87d2d..aedac4092 100644
--- a/ErsatzTV.Application/Watermarks/Queries/GetWatermarkById.cs
+++ b/ErsatzTV.Application/Watermarks/Queries/GetWatermarkById.cs
@@ -1,7 +1,3 @@
-using LanguageExt;
-using MediatR;
+namespace ErsatzTV.Application.Watermarks;
 
-namespace ErsatzTV.Application.Watermarks.Queries
-{
-    public record GetWatermarkById(int Id) : IRequest<Option<WatermarkViewModel>>;
-}
+public record GetWatermarkById(int Id) : IRequest<Option<WatermarkViewModel>>;
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/Queries/GetWatermarkByIdHandler.cs b/ErsatzTV.Application/Watermarks/Queries/GetWatermarkByIdHandler.cs
index 9d31b90c3..3635c90af 100644
--- a/ErsatzTV.Application/Watermarks/Queries/GetWatermarkByIdHandler.cs
+++ b/ErsatzTV.Application/Watermarks/Queries/GetWatermarkByIdHandler.cs
@@ -1,29 +1,24 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
 using static ErsatzTV.Application.Watermarks.Mapper;
 
-namespace ErsatzTV.Application.Watermarks.Queries
+namespace ErsatzTV.Application.Watermarks;
+
+public class GetWatermarkByIdHandler : IRequestHandler<GetWatermarkById, Option<WatermarkViewModel>>
 {
-    public class GetWatermarkByIdHandler : IRequestHandler<GetWatermarkById, Option<WatermarkViewModel>>
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public GetWatermarkByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Option<WatermarkViewModel>> Handle(
+        GetWatermarkById request,
+        CancellationToken cancellationToken)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public GetWatermarkByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Option<WatermarkViewModel>> Handle(
-            GetWatermarkById request,
-            CancellationToken cancellationToken)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.ChannelWatermarks
-                .SelectOneAsync(w => w.Id, w => w.Id == request.Id)
-                .MapT(ProjectToViewModel);
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.ChannelWatermarks
+            .SelectOneAsync(w => w.Id, w => w.Id == request.Id)
+            .MapT(ProjectToViewModel);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Application/Watermarks/WatermarkViewModel.cs b/ErsatzTV.Application/Watermarks/WatermarkViewModel.cs
index f2105aaf9..b040baa6a 100644
--- a/ErsatzTV.Application/Watermarks/WatermarkViewModel.cs
+++ b/ErsatzTV.Application/Watermarks/WatermarkViewModel.cs
@@ -1,21 +1,20 @@
 using ErsatzTV.Core.Domain;
 using ErsatzTV.FFmpeg.State;
 
-namespace ErsatzTV.Application.Watermarks
-{
-    public record WatermarkViewModel(
-        int Id,
-        string Image,
-        string Name,
-        ChannelWatermarkMode Mode,
-        ChannelWatermarkImageSource ImageSource,
-        WatermarkLocation Location,
-        WatermarkSize Size,
-        int Width,
-        int HorizontalMargin,
-        int VerticalMargin,
-        int FrequencyMinutes,
-        int DurationSeconds,
-        int Opacity
-    );
-}
+namespace ErsatzTV.Application.Watermarks;
+
+public record WatermarkViewModel(
+    int Id,
+    string Image,
+    string Name,
+    ChannelWatermarkMode Mode,
+    ChannelWatermarkImageSource ImageSource,
+    WatermarkLocation Location,
+    WatermarkSize Size,
+    int Width,
+    int HorizontalMargin,
+    int VerticalMargin,
+    int FrequencyMinutes,
+    int DurationSeconds,
+    int Opacity
+);
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj b/ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj
index 75ea6d8b3..d6993f80f 100644
--- a/ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj
+++ b/ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj
@@ -3,6 +3,7 @@
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
+        <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs b/ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs
index e794dc21a..4f68a8d59 100644
--- a/ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/FFmpegComplexFilterBuilderTests.cs
@@ -1,782 +1,777 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.FFmpeg.State;
 using FluentAssertions;
-using LanguageExt;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.FFmpeg
+namespace ErsatzTV.Core.Tests.FFmpeg;
+
+[TestFixture]
+public class FFmpegComplexFilterBuilderTests
 {
     [TestFixture]
-    public class FFmpegComplexFilterBuilderTests
+    public class Build
     {
-        [TestFixture]
-        public class Build
+        [Test]
+        public void Should_Return_None_With_No_Filters()
         {
-            [Test]
-            public void Should_Return_None_With_No_Filters()
-            {
-                var builder = new FFmpegComplexFilterBuilder();
+            var builder = new FFmpegComplexFilterBuilder();
 
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
-                result.IsNone.Should().BeTrue();
-            }
+            result.IsNone.Should().BeTrue();
+        }
 
-            [Test]
-            public void Should_Return_Audio_Filter_With_AudioDuration()
-            {
-                var duration = TimeSpan.FromMilliseconds(1000.1);
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithAlignedAudio(duration);
+        [Test]
+        public void Should_Return_Audio_Filter_With_AudioDuration()
+        {
+            var duration = TimeSpan.FromMilliseconds(1000.1);
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithAlignedAudio(duration);
 
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be("[0:1]apad=whole_dur=1000.1ms[a]");
-                        filter.AudioLabel.Should().Be("[a]");
-                        filter.VideoLabel.Should().Be("0:0");
-                    });
-            }
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be("[0:1]apad=whole_dur=1000.1ms[a]");
+                    filter.AudioLabel.Should().Be("[a]");
+                    filter.VideoLabel.Should().Be("0:0");
+                });
+        }
             
-            [Test]
-            // this needs to be a culture where '.' is a group separator
-            [SetCulture("it-IT")] 
-            public void Should_Return_Audio_Filter_With_AudioDuration_Decimal()
+        [Test]
+        // this needs to be a culture where '.' is a group separator
+        [SetCulture("it-IT")] 
+        public void Should_Return_Audio_Filter_With_AudioDuration_Decimal()
+        {
+            var duration = TimeSpan.FromMilliseconds(1000.1);
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithAlignedAudio(duration);
+
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be("[0:1]apad=whole_dur=1000.1ms[a]");
+                    filter.AudioLabel.Should().Be("[a]");
+                    filter.VideoLabel.Should().Be("0:0");
+                });
+        }
+
+        [Test]
+        public void Should_Return_Audio_And_Video_Filter()
+        {
+            var duration = TimeSpan.FromMinutes(54);
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithAlignedAudio(duration)
+                .WithDeinterlace(true);
+
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be(
+                        $"[0:1]apad=whole_dur={duration.TotalMilliseconds}ms[a];[0:0]yadif=1[v]");
+                    filter.AudioLabel.Should().Be("[a]");
+                    filter.VideoLabel.Should().Be("[v]");
+                });
+        }
+
+        [Test]
+        [TestCase(true, false, false, "[0:0]yadif=1[v]", "[v]")]
+        [TestCase(true, true, false, "[0:0]yadif=1,scale=1920:1000:flags=fast_bilinear,setsar=1[v]", "[v]")]
+        [TestCase(true, false, true, "[0:0]yadif=1,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]", "[v]")]
+        [TestCase(
+            true,
+            true,
+            true,
+            "[0:0]yadif=1,scale=1920:1000:flags=fast_bilinear,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]",
+            "[v]")]
+        [TestCase(false, true, false, "[0:0]scale=1920:1000:flags=fast_bilinear,setsar=1[v]", "[v]")]
+        [TestCase(false, false, true, "[0:0]setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]", "[v]")]
+        [TestCase(
+            false,
+            true,
+            true,
+            "[0:0]scale=1920:1000:flags=fast_bilinear,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]",
+            "[v]")]
+        public void Should_Return_Software_Video_Filter(
+            bool deinterlace,
+            bool scale,
+            bool pad,
+            string expectedVideoFilter,
+            string expectedVideoLabel)
+        {
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithDeinterlace(deinterlace);
+
+            if (scale)
             {
-                var duration = TimeSpan.FromMilliseconds(1000.1);
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithAlignedAudio(duration);
-
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
-
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be("[0:1]apad=whole_dur=1000.1ms[a]");
-                        filter.AudioLabel.Should().Be("[a]");
-                        filter.VideoLabel.Should().Be("0:0");
-                    });
+                builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1000 });
             }
 
-            [Test]
-            public void Should_Return_Audio_And_Video_Filter()
+            if (pad)
             {
-                var duration = TimeSpan.FromMinutes(54);
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithAlignedAudio(duration)
-                    .WithDeinterlace(true);
-
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
-
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be(
-                            $"[0:1]apad=whole_dur={duration.TotalMilliseconds}ms[a];[0:0]yadif=1[v]");
-                        filter.AudioLabel.Should().Be("[a]");
-                        filter.VideoLabel.Should().Be("[v]");
-                    });
+                builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
             }
 
-            [Test]
-            [TestCase(true, false, false, "[0:0]yadif=1[v]", "[v]")]
-            [TestCase(true, true, false, "[0:0]yadif=1,scale=1920:1000:flags=fast_bilinear,setsar=1[v]", "[v]")]
-            [TestCase(true, false, true, "[0:0]yadif=1,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]", "[v]")]
-            [TestCase(
-                true,
-                true,
-                true,
-                "[0:0]yadif=1,scale=1920:1000:flags=fast_bilinear,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]",
-                "[v]")]
-            [TestCase(false, true, false, "[0:0]scale=1920:1000:flags=fast_bilinear,setsar=1[v]", "[v]")]
-            [TestCase(false, false, true, "[0:0]setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]", "[v]")]
-            [TestCase(
-                false,
-                true,
-                true,
-                "[0:0]scale=1920:1000:flags=fast_bilinear,setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2[v]",
-                "[v]")]
-            public void Should_Return_Software_Video_Filter(
-                bool deinterlace,
-                bool scale,
-                bool pad,
-                string expectedVideoFilter,
-                string expectedVideoLabel)
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be(expectedVideoFilter);
+                    filter.AudioLabel.Should().Be("0:1");
+                    filter.VideoLabel.Should().Be(expectedVideoLabel);
+                });
+        }
+
+        [Test]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.BottomLeft,
+            false,
+            100,
+            "[0:0][1:v]overlay=x=134:y=H-h-54[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.BottomRight,
+            false,
+            100,
+            "[0:0][1:v]overlay=x=W-w-134:y=H-h-54[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[0:0][1:v]overlay=x=134:y=54[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.TopRight,
+            false,
+            100,
+            "[0:0][1:v]overlay=x=W-w-134:y=54[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            false,
+            false,
+            true,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[1:v]format=yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)'[wmp];[0:0][wmp]overlay=x=134:y=54,format=nv12[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            true,
+            100,
+            "[1:v]scale=384:-1[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            90,
+            "[1:v]format=yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8,colorchannelmixer=aa=0.90[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            false,
+            true,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            false,
+            true,
+            false,
+            WatermarkLocation.TopLeft,
+            true,
+            100,
+            "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
+            "0:1",
+            "[v]")]
+        [TestCase(
+            true,
+            true,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[0:1]apad=whole_dur=3300000ms[a];[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
+            "[a]",
+            "[v]")]
+        [TestCase(
+            true,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[0:1]apad=whole_dur=3300000ms[a];[0:0][1:v]overlay=x=134:y=54[v]",
+            "[a]",
+            "[v]")]
+        public void Should_Return_Watermark(
+            bool alignAudio,
+            bool deinterlace,
+            bool intermittent,
+            WatermarkLocation location,
+            bool scaled,
+            int opacity,
+            string expectedVideoFilter,
+            string expectedAudioLabel,
+            string expectedVideoLabel)
+        {
+            var watermark = new ChannelWatermark
             {
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithDeinterlace(deinterlace);
+                Mode = intermittent
+                    ? ChannelWatermarkMode.Intermittent
+                    : ChannelWatermarkMode.Permanent,
+                DurationSeconds = intermittent ? 15 : 0,
+                FrequencyMinutes = intermittent ? 10 : 0,
+                Location = location,
+                Size = scaled ? WatermarkSize.Scaled : WatermarkSize.ActualSize,
+                WidthPercent = scaled ? 20 : 0,
+                Opacity = opacity,
+                HorizontalMarginPercent = 7,
+                VerticalMarginPercent = 5
+            };
 
-                if (scale)
-                {
-                    builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1000 });
-                }
-
-                if (pad)
-                {
-                    builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
-                }
-
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
-
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be("0:1");
-                        filter.VideoLabel.Should().Be(expectedVideoLabel);
-                    });
-            }
-
-            [Test]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.BottomLeft,
-                false,
-                100,
-                "[0:0][1:v]overlay=x=134:y=H-h-54[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.BottomRight,
-                false,
-                100,
-                "[0:0][1:v]overlay=x=W-w-134:y=H-h-54[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:0][1:v]overlay=x=134:y=54[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopRight,
-                false,
-                100,
-                "[0:0][1:v]overlay=x=W-w-134:y=54[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                false,
-                false,
-                true,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[1:v]format=yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)'[wmp];[0:0][wmp]overlay=x=134:y=54,format=nv12[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                true,
-                100,
-                "[1:v]scale=384:-1[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                90,
-                "[1:v]format=yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8,colorchannelmixer=aa=0.90[wmp];[0:0][wmp]overlay=x=134:y=54[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                false,
-                true,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                false,
-                true,
-                false,
-                WatermarkLocation.TopLeft,
-                true,
-                100,
-                "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
-                "0:1",
-                "[v]")]
-            [TestCase(
-                true,
-                true,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:1]apad=whole_dur=3300000ms[a];[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
-                "[a]",
-                "[v]")]
-            [TestCase(
-                true,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:1]apad=whole_dur=3300000ms[a];[0:0][1:v]overlay=x=134:y=54[v]",
-                "[a]",
-                "[v]")]
-            public void Should_Return_Watermark(
-                bool alignAudio,
-                bool deinterlace,
-                bool intermittent,
-                WatermarkLocation location,
-                bool scaled,
-                int opacity,
-                string expectedVideoFilter,
-                string expectedAudioLabel,
-                string expectedVideoLabel)
-            {
-                var watermark = new ChannelWatermark
-                {
-                    Mode = intermittent
-                        ? ChannelWatermarkMode.Intermittent
-                        : ChannelWatermarkMode.Permanent,
-                    DurationSeconds = intermittent ? 15 : 0,
-                    FrequencyMinutes = intermittent ? 10 : 0,
-                    Location = location,
-                    Size = scaled ? WatermarkSize.Scaled : WatermarkSize.ActualSize,
-                    WidthPercent = scaled ? 20 : 0,
-                    Opacity = opacity,
-                    HorizontalMarginPercent = 7,
-                    VerticalMarginPercent = 5
-                };
-
-                Option<List<FadePoint>> maybeFadePoints = watermark.Mode == ChannelWatermarkMode.Intermittent
-                    ? Some(
-                        WatermarkCalculator.CalculateFadePoints(
-                            new DateTimeOffset(2022, 01, 31, 12, 25, 0, TimeSpan.FromHours(-5)),
-                            TimeSpan.Zero,
-                            TimeSpan.FromMinutes(55),
-                            TimeSpan.Zero,
-                            watermark.FrequencyMinutes,
-                            watermark.DurationSeconds))
-                    : None;
+            Option<List<FadePoint>> maybeFadePoints = watermark.Mode == ChannelWatermarkMode.Intermittent
+                ? Some(
+                    WatermarkCalculator.CalculateFadePoints(
+                        new DateTimeOffset(2022, 01, 31, 12, 25, 0, TimeSpan.FromHours(-5)),
+                        TimeSpan.Zero,
+                        TimeSpan.FromMinutes(55),
+                        TimeSpan.Zero,
+                        watermark.FrequencyMinutes,
+                        watermark.DurationSeconds))
+                : None;
                 
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithWatermark(
-                        Some(watermark),
-                        maybeFadePoints,
-                        new Resolution { Width = 1920, Height = 1080 },
-                        None)
-                    .WithDeinterlace(deinterlace)
-                    .WithAlignedAudio(alignAudio ? Some(TimeSpan.FromMinutes(55)) : None);
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithWatermark(
+                    Some(watermark),
+                    maybeFadePoints,
+                    new Resolution { Width = 1920, Height = 1080 },
+                    None)
+                .WithDeinterlace(deinterlace)
+                .WithAlignedAudio(alignAudio ? Some(TimeSpan.FromMinutes(55)) : None);
 
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
 
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be(expectedAudioLabel);
-                        filter.VideoLabel.Should().Be(expectedVideoLabel);
-                    });
-            }
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be(expectedVideoFilter);
+                    filter.AudioLabel.Should().Be(expectedAudioLabel);
+                    filter.VideoLabel.Should().Be(expectedVideoLabel);
+                });
+        }
             
-            [Test]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.BottomLeft,
-                false,
-                100,
-                "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=H-h-54[v]",
-                "0:1",
-                "[v]",
-                false)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.BottomLeft,
-                false,
-                100,
-                "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=H-h-54,hwupload[v]",
-                "0:1",
-                "[v]",
-                true)]
-            [TestCase(
-                false,
-                false,
-                true,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)',hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
-                "0:1",
-                "[v]",
-                false)]
-            [TestCase(
-                false,
-                false,
-                true,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)',hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
-                "0:1",
-                "[v]",
-                true)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                true,
-                100,
-                "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,scale=384:-1,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
-                "0:1",
-                "[v]",
-                false)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                true,
-                100,
-                "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,scale=384:-1,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
-                "0:1",
-                "[v]",
-                true)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                90,
-                "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,colorchannelmixer=aa=0.90,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
-                "0:1",
-                "[v]",
-                false)]
-            [TestCase(
-                false,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                90,
-                "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,colorchannelmixer=aa=0.90,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
-                "0:1",
-                "[v]",
-                true)]            
-            // TODO: do we need these anymore? interlaced content that isn't handled by mpeg2_cuvid?
-            // [TestCase(
-            //     false,
-            //     true,
-            //     false,
-            //     WatermarkLocation.TopLeft,
-            //     false,
-            //     100,
-            //     "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
-            //     "0:1",
-            //     "[v]")]
-            // [TestCase(
-            //     false,
-            //     true,
-            //     false,
-            //     WatermarkLocation.TopLeft,
-            //     true,
-            //     100,
-            //     "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
-            //     "0:1",
-            //     "[v]")]
-            // [TestCase(
-            //     true,
-            //     true,
-            //     false,
-            //     WatermarkLocation.TopLeft,
-            //     false,
-            //     100,
-            //     "[0:1]apad=whole_dur=3300000ms[a];[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
-            //     "[a]",
-            //     "[v]")]
-            [TestCase(
-                true,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:1]apad=whole_dur=3300000ms[a];[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
-                "[a]",
-                "[v]",
-                false)]
-            [TestCase(
-                true,
-                false,
-                false,
-                WatermarkLocation.TopLeft,
-                false,
-                100,
-                "[0:1]apad=whole_dur=3300000ms[a];[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
-                "[a]",
-                "[v]",
-                true)]
-            public void Should_Return_NVENC_Watermark(
-                bool alignAudio,
-                bool deinterlace,
-                bool intermittent,
-                WatermarkLocation location,
-                bool scaled,
-                int opacity,
-                string expectedVideoFilter,
-                string expectedAudioLabel,
-                string expectedVideoLabel,
-                bool scaledSource)
+        [Test]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.BottomLeft,
+            false,
+            100,
+            "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=H-h-54[v]",
+            "0:1",
+            "[v]",
+            false)]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.BottomLeft,
+            false,
+            100,
+            "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=H-h-54,hwupload[v]",
+            "0:1",
+            "[v]",
+            true)]
+        [TestCase(
+            false,
+            false,
+            true,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)',hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
+            "0:1",
+            "[v]",
+            false)]
+        [TestCase(
+            false,
+            false,
+            true,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,fade=in:st=300:d=1:alpha=1:enable='between(t,0,314)',fade=out:st=315:d=1:alpha=1:enable='between(t,301,899)',fade=in:st=900:d=1:alpha=1:enable='between(t,316,914)',fade=out:st=915:d=1:alpha=1:enable='between(t,901,1499)',fade=in:st=1500:d=1:alpha=1:enable='between(t,916,1514)',fade=out:st=1515:d=1:alpha=1:enable='between(t,1501,2099)',fade=in:st=2100:d=1:alpha=1:enable='between(t,1516,2114)',fade=out:st=2115:d=1:alpha=1:enable='between(t,2101,2699)',fade=in:st=2700:d=1:alpha=1:enable='between(t,2116,2714)',fade=out:st=2715:d=1:alpha=1:enable='between(t,2701,3300)',hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
+            "0:1",
+            "[v]",
+            true)]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            true,
+            100,
+            "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,scale=384:-1,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
+            "0:1",
+            "[v]",
+            false)]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            true,
+            100,
+            "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,scale=384:-1,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
+            "0:1",
+            "[v]",
+            true)]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            90,
+            "[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,colorchannelmixer=aa=0.90,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
+            "0:1",
+            "[v]",
+            false)]
+        [TestCase(
+            false,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            90,
+            "[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,colorchannelmixer=aa=0.90,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
+            "0:1",
+            "[v]",
+            true)]            
+        // TODO: do we need these anymore? interlaced content that isn't handled by mpeg2_cuvid?
+        // [TestCase(
+        //     false,
+        //     true,
+        //     false,
+        //     WatermarkLocation.TopLeft,
+        //     false,
+        //     100,
+        //     "[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
+        //     "0:1",
+        //     "[v]")]
+        // [TestCase(
+        //     false,
+        //     true,
+        //     false,
+        //     WatermarkLocation.TopLeft,
+        //     true,
+        //     100,
+        //     "[0:0]yadif=1[vt];[1:v]scale=384:-1[wmp];[vt][wmp]overlay=x=134:y=54[v]",
+        //     "0:1",
+        //     "[v]")]
+        // [TestCase(
+        //     true,
+        //     true,
+        //     false,
+        //     WatermarkLocation.TopLeft,
+        //     false,
+        //     100,
+        //     "[0:1]apad=whole_dur=3300000ms[a];[0:0]yadif=1[vt];[vt][1:v]overlay=x=134:y=54[v]",
+        //     "[a]",
+        //     "[v]")]
+        [TestCase(
+            true,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[0:1]apad=whole_dur=3300000ms[a];[0:0]scale_cuda=format=yuv420p[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54[v]",
+            "[a]",
+            "[v]",
+            false)]
+        [TestCase(
+            true,
+            false,
+            false,
+            WatermarkLocation.TopLeft,
+            false,
+            100,
+            "[0:1]apad=whole_dur=3300000ms[a];[0:0]scale_cuda=1920:1080,setsar=1,hwdownload,format=nv12,format=yuv420p,hwupload_cuda[vt];[1:v]format=yuva420p,hwupload_cuda[wmp];[vt][wmp]overlay_cuda=x=134:y=54,hwupload[v]",
+            "[a]",
+            "[v]",
+            true)]
+        public void Should_Return_NVENC_Watermark(
+            bool alignAudio,
+            bool deinterlace,
+            bool intermittent,
+            WatermarkLocation location,
+            bool scaled,
+            int opacity,
+            string expectedVideoFilter,
+            string expectedAudioLabel,
+            string expectedVideoLabel,
+            bool scaledSource)
+        {
+            var watermark = new ChannelWatermark
             {
-                var watermark = new ChannelWatermark
-                {
-                    Mode = intermittent
-                        ? ChannelWatermarkMode.Intermittent
-                        : ChannelWatermarkMode.Permanent,
-                    DurationSeconds = intermittent ? 15 : 0,
-                    FrequencyMinutes = intermittent ? 10 : 0,
-                    Location = location,
-                    Size = scaled ? WatermarkSize.Scaled : WatermarkSize.ActualSize,
-                    WidthPercent = scaled ? 20 : 0,
-                    Opacity = opacity,
-                    HorizontalMarginPercent = 7,
-                    VerticalMarginPercent = 5
-                };
+                Mode = intermittent
+                    ? ChannelWatermarkMode.Intermittent
+                    : ChannelWatermarkMode.Permanent,
+                DurationSeconds = intermittent ? 15 : 0,
+                FrequencyMinutes = intermittent ? 10 : 0,
+                Location = location,
+                Size = scaled ? WatermarkSize.Scaled : WatermarkSize.ActualSize,
+                WidthPercent = scaled ? 20 : 0,
+                Opacity = opacity,
+                HorizontalMarginPercent = 7,
+                VerticalMarginPercent = 5
+            };
 
-                Option<List<FadePoint>> maybeFadePoints = watermark.Mode == ChannelWatermarkMode.Intermittent
-                    ? Some(
-                        WatermarkCalculator.CalculateFadePoints(
-                            new DateTimeOffset(2022, 01, 31, 12, 25, 0, TimeSpan.FromHours(-5)),
-                            TimeSpan.Zero,
-                            TimeSpan.FromMinutes(55),
-                            TimeSpan.Zero,
-                            watermark.FrequencyMinutes,
-                            watermark.DurationSeconds))
-                    : None;
+            Option<List<FadePoint>> maybeFadePoints = watermark.Mode == ChannelWatermarkMode.Intermittent
+                ? Some(
+                    WatermarkCalculator.CalculateFadePoints(
+                        new DateTimeOffset(2022, 01, 31, 12, 25, 0, TimeSpan.FromHours(-5)),
+                        TimeSpan.Zero,
+                        TimeSpan.FromMinutes(55),
+                        TimeSpan.Zero,
+                        watermark.FrequencyMinutes,
+                        watermark.DurationSeconds))
+                : None;
                 
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithHardwareAcceleration(HardwareAccelerationKind.Nvenc)
-                    .WithWatermark(
-                        Some(watermark),
-                        maybeFadePoints,
-                        new Resolution { Width = 1920, Height = 1080 },
-                        None)
-                    .WithDeinterlace(deinterlace)
-                    .WithAlignedAudio(alignAudio ? Some(TimeSpan.FromMinutes(55)) : None);
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithHardwareAcceleration(HardwareAccelerationKind.Nvenc)
+                .WithWatermark(
+                    Some(watermark),
+                    maybeFadePoints,
+                    new Resolution { Width = 1920, Height = 1080 },
+                    None)
+                .WithDeinterlace(deinterlace)
+                .WithAlignedAudio(alignAudio ? Some(TimeSpan.FromMinutes(55)) : None);
 
-                if (scaledSource)
-                {
-                    builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1080 });
-                }
-
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
-
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be(expectedAudioLabel);
-                        filter.VideoLabel.Should().Be(expectedVideoLabel);
-                    });
-            }
-
-            [Test]
-            [TestCase(true, false, false, "[0:0]deinterlace_qsv[v]", "[v]")]
-            [TestCase(
-                true,
-                true,
-                false,
-                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1[v]",
-                "[v]")]
-            [TestCase(
-                true,
-                false,
-                true,
-                "[0:0]deinterlace_qsv,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
-                "[v]")]
-            [TestCase(
-                true,
-                true,
-                true,
-                "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
-                "[v]")]
-            [TestCase(
-                false,
-                true,
-                false,
-                "[0:0]scale_qsv=w=1920:h=1000,setsar=1[v]",
-                "[v]")]
-            [TestCase(
-                false,
-                false,
-                true,
-                "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
-                "[v]")]
-            [TestCase(
-                false,
-                true,
-                true,
-                "[0:0]scale_qsv=w=1920:h=1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
-                "[v]")]
-            public void Should_Return_QSV_Video_Filter(
-                bool deinterlace,
-                bool scale,
-                bool pad,
-                string expectedVideoFilter,
-                string expectedVideoLabel)
+            if (scaledSource)
             {
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithHardwareAcceleration(HardwareAccelerationKind.Qsv)
-                    .WithDeinterlace(deinterlace);
-
-                if (scale)
-                {
-                    builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1000 });
-                }
-
-                if (pad)
-                {
-                    builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
-                }
-
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
-
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be("0:1");
-                        filter.VideoLabel.Should().Be(expectedVideoLabel);
-                    });
+                builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1080 });
             }
 
-            [Test]
-            [TestCase(true, false, false, "[0:0]yadif_cuda[v]", "[v]")]
-            [TestCase(
-                true,
-                true,
-                false,
-                "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1[v]",
-                "[v]")]
-            [TestCase(
-                true,
-                false,
-                true,
-                "[0:0]yadif_cuda,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                true,
-                true,
-                true,
-                "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                false,
-                true,
-                false,
-                "[0:0]scale_cuda=1920:1000,setsar=1[v]",
-                "[v]")]
-            [TestCase(
-                false,
-                false,
-                true,
-                "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                false,
-                true,
-                true,
-                "[0:0]scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            public void Should_Return_NVENC_Video_Filter(
-                bool deinterlace,
-                bool scale,
-                bool pad,
-                string expectedVideoFilter,
-                string expectedVideoLabel)
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be(expectedVideoFilter);
+                    filter.AudioLabel.Should().Be(expectedAudioLabel);
+                    filter.VideoLabel.Should().Be(expectedVideoLabel);
+                });
+        }
+
+        [Test]
+        [TestCase(true, false, false, "[0:0]deinterlace_qsv[v]", "[v]")]
+        [TestCase(
+            true,
+            true,
+            false,
+            "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1[v]",
+            "[v]")]
+        [TestCase(
+            true,
+            false,
+            true,
+            "[0:0]deinterlace_qsv,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+            "[v]")]
+        [TestCase(
+            true,
+            true,
+            true,
+            "[0:0]deinterlace_qsv,scale_qsv=w=1920:h=1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+            "[v]")]
+        [TestCase(
+            false,
+            true,
+            false,
+            "[0:0]scale_qsv=w=1920:h=1000,setsar=1[v]",
+            "[v]")]
+        [TestCase(
+            false,
+            false,
+            true,
+            "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+            "[v]")]
+        [TestCase(
+            false,
+            true,
+            true,
+            "[0:0]scale_qsv=w=1920:h=1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload=extra_hw_frames=64[v]",
+            "[v]")]
+        public void Should_Return_QSV_Video_Filter(
+            bool deinterlace,
+            bool scale,
+            bool pad,
+            string expectedVideoFilter,
+            string expectedVideoLabel)
+        {
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithHardwareAcceleration(HardwareAccelerationKind.Qsv)
+                .WithDeinterlace(deinterlace);
+
+            if (scale)
             {
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithHardwareAcceleration(HardwareAccelerationKind.Nvenc)
-                    .WithDeinterlace(deinterlace)
-                    .WithInputPixelFormat("h264");
-
-                if (scale)
-                {
-                    builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1000 });
-                }
-
-                if (pad)
-                {
-                    builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
-                }
-
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
-
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be("0:1");
-                        filter.VideoLabel.Should().Be(expectedVideoLabel);
-                    });
+                builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1000 });
             }
 
-            [Test]
-            [TestCase("h264", true, false, false, "[0:0]deinterlace_vaapi[v]", "[v]")]
-            [TestCase(
-                "h264",
-                true,
-                true,
-                false,
-                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
-                "[v]")]
-            [TestCase(
-                "h264",
-                true,
-                false,
-                true,
-                "[0:0]deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                "h264",
-                true,
-                true,
-                true,
-                "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                "h264",
-                false,
-                true,
-                false,
-                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
-                "[v]")]
-            [TestCase(
-                "h264",
-                false,
-                false,
-                true,
-                "[0:0]setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                "h264",
-                false,
-                true,
-                true,
-                "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase("mpeg4", true, false, false, "[0:0]hwupload,deinterlace_vaapi[v]", "[v]")]
-            [TestCase(
-                "mpeg4",
-                true,
-                true,
-                false,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
-                "[v]")]
-            [TestCase(
-                "mpeg4",
-                true,
-                false,
-                true,
-                "[0:0]hwupload,deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                "mpeg4",
-                true,
-                true,
-                true,
-                "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                "mpeg4",
-                false,
-                true,
-                false,
-                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
-                "[v]")]
-            [TestCase(
-                "mpeg4",
-                false,
-                false,
-                true,
-                "[0:0]setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            [TestCase(
-                "mpeg4",
-                false,
-                true,
-                true,
-                "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
-                "[v]")]
-            public void Should_Return_VAAPI_Video_Filter(
-                string codec,
-                bool deinterlace,
-                bool scale,
-                bool pad,
-                string expectedVideoFilter,
-                string expectedVideoLabel)
+            if (pad)
             {
-                FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
-                    .WithHardwareAcceleration(HardwareAccelerationKind.Vaapi)
-                    .WithInputCodec(codec)
-                    .WithDeinterlace(deinterlace);
-
-                if (scale)
-                {
-                    builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1000 });
-                }
-
-                if (pad)
-                {
-                    builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
-                }
-
-                Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
-
-                result.IsSome.Should().BeTrue();
-                result.IfSome(
-                    filter =>
-                    {
-                        filter.ComplexFilter.Should().Be(expectedVideoFilter);
-                        filter.AudioLabel.Should().Be("0:1");
-                        filter.VideoLabel.Should().Be(expectedVideoLabel);
-                    });
+                builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
             }
+
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be(expectedVideoFilter);
+                    filter.AudioLabel.Should().Be("0:1");
+                    filter.VideoLabel.Should().Be(expectedVideoLabel);
+                });
+        }
+
+        [Test]
+        [TestCase(true, false, false, "[0:0]yadif_cuda[v]", "[v]")]
+        [TestCase(
+            true,
+            true,
+            false,
+            "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1[v]",
+            "[v]")]
+        [TestCase(
+            true,
+            false,
+            true,
+            "[0:0]yadif_cuda,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            true,
+            true,
+            true,
+            "[0:0]yadif_cuda,scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            false,
+            true,
+            false,
+            "[0:0]scale_cuda=1920:1000,setsar=1[v]",
+            "[v]")]
+        [TestCase(
+            false,
+            false,
+            true,
+            "[0:0]setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            false,
+            true,
+            true,
+            "[0:0]scale_cuda=1920:1000,setsar=1,hwdownload,format=nv12,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        public void Should_Return_NVENC_Video_Filter(
+            bool deinterlace,
+            bool scale,
+            bool pad,
+            string expectedVideoFilter,
+            string expectedVideoLabel)
+        {
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithHardwareAcceleration(HardwareAccelerationKind.Nvenc)
+                .WithDeinterlace(deinterlace)
+                .WithInputPixelFormat("h264");
+
+            if (scale)
+            {
+                builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1000 });
+            }
+
+            if (pad)
+            {
+                builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
+            }
+
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be(expectedVideoFilter);
+                    filter.AudioLabel.Should().Be("0:1");
+                    filter.VideoLabel.Should().Be(expectedVideoLabel);
+                });
+        }
+
+        [Test]
+        [TestCase("h264", true, false, false, "[0:0]deinterlace_vaapi[v]", "[v]")]
+        [TestCase(
+            "h264",
+            true,
+            true,
+            false,
+            "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
+            "[v]")]
+        [TestCase(
+            "h264",
+            true,
+            false,
+            true,
+            "[0:0]deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            "h264",
+            true,
+            true,
+            true,
+            "[0:0]deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            "h264",
+            false,
+            true,
+            false,
+            "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
+            "[v]")]
+        [TestCase(
+            "h264",
+            false,
+            false,
+            true,
+            "[0:0]setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            "h264",
+            false,
+            true,
+            true,
+            "[0:0]scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase("mpeg4", true, false, false, "[0:0]hwupload,deinterlace_vaapi[v]", "[v]")]
+        [TestCase(
+            "mpeg4",
+            true,
+            true,
+            false,
+            "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
+            "[v]")]
+        [TestCase(
+            "mpeg4",
+            true,
+            false,
+            true,
+            "[0:0]hwupload,deinterlace_vaapi,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            "mpeg4",
+            true,
+            true,
+            true,
+            "[0:0]hwupload,deinterlace_vaapi,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            "mpeg4",
+            false,
+            true,
+            false,
+            "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1[v]",
+            "[v]")]
+        [TestCase(
+            "mpeg4",
+            false,
+            false,
+            true,
+            "[0:0]setsar=1,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        [TestCase(
+            "mpeg4",
+            false,
+            true,
+            true,
+            "[0:0]hwupload,scale_vaapi=format=nv12:w=1920:h=1000,setsar=1,hwdownload,format=nv12|vaapi,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,hwupload[v]",
+            "[v]")]
+        public void Should_Return_VAAPI_Video_Filter(
+            string codec,
+            bool deinterlace,
+            bool scale,
+            bool pad,
+            string expectedVideoFilter,
+            string expectedVideoLabel)
+        {
+            FFmpegComplexFilterBuilder builder = new FFmpegComplexFilterBuilder()
+                .WithHardwareAcceleration(HardwareAccelerationKind.Vaapi)
+                .WithInputCodec(codec)
+                .WithDeinterlace(deinterlace);
+
+            if (scale)
+            {
+                builder = builder.WithScaling(new Resolution { Width = 1920, Height = 1000 });
+            }
+
+            if (pad)
+            {
+                builder = builder.WithBlackBars(new Resolution { Width = 1920, Height = 1080 });
+            }
+
+            Option<FFmpegComplexFilter> result = builder.Build(false, 0, 0, 0, 1, false);
+
+            result.IsSome.Should().BeTrue();
+            result.IfSome(
+                filter =>
+                {
+                    filter.ComplexFilter.Should().Be(expectedVideoFilter);
+                    filter.AudioLabel.Should().Be("0:1");
+                    filter.VideoLabel.Should().Be(expectedVideoLabel);
+                });
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs b/ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs
index e289a18ba..2a05e9277 100644
--- a/ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/FFmpegPlaybackSettingsCalculatorTests.cs
@@ -1,1187 +1,1184 @@
-using System;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.FFmpeg
+namespace ErsatzTV.Core.Tests.FFmpeg;
+
+[TestFixture]
+public class FFmpegPlaybackSettingsCalculatorTests
 {
     [TestFixture]
-    public class FFmpegPlaybackSettingsCalculatorTests
+    public class CalculateSettings
     {
-        [TestFixture]
-        public class CalculateSettings
-        {
-            private readonly FFmpegPlaybackSettingsCalculator _calculator;
+        private readonly FFmpegPlaybackSettingsCalculator _calculator;
 
-            public CalculateSettings() => _calculator = new FFmpegPlaybackSettingsCalculator();
+        public CalculateSettings() => _calculator = new FFmpegPlaybackSettingsCalculator();
             
-            [Test]
-            public void Should_Not_GenPts_ForHlsSegmenter()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile();
+        [Test]
+        public void Should_Not_GenPts_ForHlsSegmenter()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile();
 
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingSegmenter,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.HttpLiveStreamingSegmenter,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
 
-                actual.FormatFlags.Should().NotContain("+genpts");
-            }
+            actual.FormatFlags.Should().NotContain("+genpts");
+        }
 
-            [Test]
-            public void Should_Not_UseSpecifiedThreadCount_ForTransportStream()
-            {
-                // MPEG-TS requires realtime output which is hardcoded to a single thread
+        [Test]
+        public void Should_Not_UseSpecifiedThreadCount_ForTransportStream()
+        {
+            // MPEG-TS requires realtime output which is hardcoded to a single thread
                 
-                FFmpegProfile ffmpegProfile = TestProfile() with { ThreadCount = 7 };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ThreadCount.Should().Be(1);
-            }
-
-            [Test]
-            public void Should_UseSpecifiedThreadCount_ForHttpLiveStreamingSegmenter()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with { ThreadCount = 7 };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingSegmenter,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ThreadCount.Should().Be(7);
-            }
-
-            [Test]
-            public void Should_SetFormatFlags_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                string[] expected = { "+genpts", "+discardcorrupt", "+igndts" };
-                actual.FormatFlags.Count.Should().Be(expected.Length);
-                actual.FormatFlags.Should().Contain(expected);
-            }
-
-            [Test]
-            public void Should_SetFormatFlags_ForHttpLiveStreaming()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingDirect,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                string[] expected = { "+genpts", "+discardcorrupt", "+igndts" };
-                actual.FormatFlags.Count.Should().Be(expected.Length);
-                actual.FormatFlags.Should().Contain(expected);
-            }
-
-            [Test]
-            public void Should_SetRealtime_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.RealtimeOutput.Should().BeTrue();
-            }
-
-            [Test]
-            public void Should_SetRealtime_ForHttpLiveStreaming()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingDirect,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.RealtimeOutput.Should().BeTrue();
-            }
-
-            [Test]
-            public void Should_SetStreamSeek_When_PlaybackIsLate_ForTransportStream()
-            {
-                DateTimeOffset now = DateTimeOffset.Now;
-
-                FFmpegProfile ffmpegProfile = TestProfile();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    now,
-                    now.AddMinutes(5),
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.StreamSeek.IsSome.Should().BeTrue();
-                actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
-            }
-
-            [Test]
-            public void Should_SetStreamSeek_When_PlaybackIsLate_ForHttpLiveStreaming()
-            {
-                DateTimeOffset now = DateTimeOffset.Now;
-
-                FFmpegProfile ffmpegProfile = TestProfile();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingDirect,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    now,
-                    now.AddMinutes(5),
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.StreamSeek.IsSome.Should().BeTrue();
-                actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
-            }
-
-            [Test]
-            public void ShouldNot_SetScaledSize_When_NotNormalizingVideo_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with { NormalizeVideo = false };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-            }
-
-            [Test]
-            public void ShouldNot_SetScaledSize_When_ContentIsCorrectSize_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 }
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-            }
-
-            [Test]
-            public void ShouldNot_SetScaledSize_When_ScaledSizeWouldEqualContentSize_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 }
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-            }
-
-            [Test]
-            public void ShouldNot_PadToDesiredResolution_When_ContentIsCorrectSize_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 }
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-            }
-
-            [Test]
-            public void Should_PadToDesiredResolution_When_UnscaledContentIsUnderSized_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 }
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeTrue();
-            }
-
-            [Test]
-            public void Should_ScaleToEvenDimensions_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1280, Height = 720 }
-                };
-
-                var version = new MediaVersion { Width = 706, Height = 362, SampleAspectRatio = "32:27" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                IDisplaySize scaledSize = actual.ScaledSize.IfNone(new MediaVersion { Width = 0, Height = 0 });
-                scaledSize.Width.Should().Be(1280);
-                scaledSize.Height.Should().Be(554);
-                actual.PadToDesiredResolution.Should().BeTrue();
-            }
-
-            [Test]
-            public void Should_NotPadToDesiredResolution_When_UnscaledContentIsUnderSized_ForHttpLiveStreaming()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 }
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingDirect,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-            }
-
-            [Test]
-            public void Should_NotPadToDesiredResolution_When_NotNormalizingVideo()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeVideo = false,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 }
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-            }
-
-            [Test]
-            public void Should_SetDesiredVideoCodec_When_ContentIsPadded_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoCodec = "testCodec"
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeTrue();
-                actual.VideoCodec.Should().Be("testCodec");
-            }
-
-            [Test]
-            public void
-                Should_SetDesiredVideoCodec_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoCodec = "testCodec"
-                };
-
-                // not anamorphic
-                var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream { Codec = "mpeg2video" },
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-                actual.VideoCodec.Should().Be("testCodec");
-            }
-
-            [Test]
-            public void
-                Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NormalizingVideo_ForHttpLiveStreaming()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoCodec = "testCodec"
-                };
-
-                // not anamorphic
-                var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingDirect,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream { Codec = "mpeg2video" },
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-                actual.VideoCodec.Should().Be("copy");
-            }
-
-            [Test]
-            public void Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_CorrectCodec_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoCodec = "libx264"
-                };
-
-                // not anamorphic
-                var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream { Codec = "libx264" },
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-                actual.VideoCodec.Should().Be("copy");
-            }
-
-            [Test]
-            public void
-                Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NotNormalizingVideo_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = false,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoCodec = "libx264"
-                };
-
-                // not anamorphic
-                var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream { Codec = "mpeg2video" },
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-                actual.VideoCodec.Should().Be("copy");
-            }
-            
-            [Test]
-            public void
-                Should_SetCopyVideoCodec_AndCopyAudioCodec_When_NotTranscoding_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = false,
-                    NormalizeVideo = true,
-                    NormalizeAudio = true,
-                    NormalizeLoudness = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoCodec = "libx264"
-                };
-
-                // not anamorphic
-                var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream { Codec = "mpeg2video" },
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-                actual.VideoCodec.Should().Be("copy");
-                actual.NormalizeLoudness.Should().BeFalse();
-                actual.AudioCodec.Should().Be("copy");
-            }
-
-            [Test]
-            public void Should_SetVideoBitrate_When_ContentIsPadded_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoBitrate = 2525
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeTrue();
-                actual.VideoBitrate.IfNone(0).Should().Be(2525);
-            }
-
-            [Test]
-            public void Should_SetVideoBitrate_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoBitrate = 2525
-                };
-
-                // not anamorphic
-                var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream { Codec = "mpeg2video" },
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-                actual.VideoBitrate.IfNone(0).Should().Be(2525);
-            }
-
-            [Test]
-            public void Should_SetVideoBufferSize_When_ContentIsPadded_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoBufferSize = 2525
-                };
-
-                // not anamorphic
-                var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeTrue();
-                actual.VideoBufferSize.IfNone(0).Should().Be(2525);
-            }
-
-            [Test]
-            public void
-                Should_SetVideoBufferSize_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
-            {
-                var ffmpegProfile = new FFmpegProfile
-                {
-                    Transcode = true,
-                    NormalizeVideo = true,
-                    Resolution = new Resolution { Width = 1920, Height = 1080 },
-                    VideoBufferSize = 2525
-                };
-
-                // not anamorphic
-                var version = new MediaVersion
-                    { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream { Codec = "mpeg2video" },
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.ScaledSize.IsNone.Should().BeTrue();
-                actual.PadToDesiredResolution.Should().BeFalse();
-                actual.VideoBufferSize.IfNone(0).Should().Be(2525);
-            }
-
-            [Test]
-            public void Should_SetDesiredAudioCodec_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioCodec = "aac"
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "aac" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioCodec.Should().Be("aac");
-            }
-
-            [Test]
-            public void Should_SetCopyAudioCodec_When_NotNormalizingAudio_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    NormalizeAudio = false,
-                    AudioCodec = "aac"
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioCodec.Should().Be("copy");
-            }
-
-            [Test]
-            public void Should_SetDesiredAudioCodec_When_NormalizingAudio_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioCodec = "aac"
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioCodec.Should().Be("aac");
-            }
-
-            [Test]
-            public void Should_SetCopyAudioCodec_When_NormalizingAudio_ForHttpLiveStreaming()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioCodec = "aac"
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.HttpLiveStreamingDirect,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioCodec.Should().Be("copy");
-            }
-
-            [Test]
-            public void Should_SetAudioBitrate_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioBitrate = 2424,
-                    AudioCodec = "ac3"
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioBitrate.IfNone(0).Should().Be(2424);
-            }
-
-            [Test]
-            public void Should_SetAudioBufferSize_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioBufferSize = 2424,
-                    AudioCodec = "ac3"
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioBufferSize.IfNone(0).Should().Be(2424);
-            }
-
-            [Test]
-            public void Should_SetAudioChannels_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioCodec = "ac3",
-                    AudioChannels = 6
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioChannels.IfNone(0).Should().Be(6);
-            }
-
-            [Test]
-            public void Should_SetAudioSampleRate_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioCodec = "ac3",
-                    AudioSampleRate = 48
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioSampleRate.IfNone(0).Should().Be(48);
-            }
-
-            [Test]
-            public void Should_SetAudioChannels_When_NormalizingAudio_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioChannels = 6
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioChannels.IfNone(0).Should().Be(6);
-            }
-
-            [Test]
-            public void Should_SetAudioSampleRate_When_NormalizingAudio_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioSampleRate = 48
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.AudioSampleRate.IfNone(0).Should().Be(48);
-            }
-
-            [Test]
-            public void Should_SetAudioDuration_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    AudioSampleRate = 48,
-                    AudioCodec = "ac3"
-                };
-
-                var version = new MediaVersion { Duration = TimeSpan.FromMinutes(5) }; // not pulled from here
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.FromMinutes(2),
-                    false,
-                    None);
-
-                actual.AudioDuration.IfNone(TimeSpan.MinValue).Should().Be(TimeSpan.FromMinutes(2));
-            }
-
-            [Test]
-            public void Should_SetNormalizeLoudness_When_NormalizingAudio_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = true,
-                    NormalizeLoudness = true
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.NormalizeLoudness.Should().BeTrue();
-            }
-
-            [Test]
-            public void Should_NotSetNormalizeLoudness_When_NotNormalizingAudio_ForTransportStream()
-            {
-                FFmpegProfile ffmpegProfile = TestProfile() with
-                {
-                    Transcode = true,
-                    NormalizeAudio = false,
-                    NormalizeLoudness = true
-                };
-
-                var version = new MediaVersion();
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    version,
-                    new MediaStream(),
-                    new MediaStream { Codec = "ac3" },
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.NormalizeLoudness.Should().BeFalse();
-            }
+            FFmpegProfile ffmpegProfile = TestProfile() with { ThreadCount = 7 };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ThreadCount.Should().Be(1);
         }
 
-        [TestFixture]
-        public class CalculateSettingsQsv
+        [Test]
+        public void Should_UseSpecifiedThreadCount_ForHttpLiveStreamingSegmenter()
         {
-            private readonly FFmpegPlaybackSettingsCalculator _calculator;
+            FFmpegProfile ffmpegProfile = TestProfile() with { ThreadCount = 7 };
 
-            public CalculateSettingsQsv() => _calculator = new FFmpegPlaybackSettingsCalculator();
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.HttpLiveStreamingSegmenter,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
 
-            [Test]
-            public void Should_UseHardwareAcceleration()
-            {
-                FFmpegProfile ffmpegProfile =
-                    TestProfile() with { HardwareAcceleration = HardwareAccelerationKind.Qsv };
-
-                FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    ffmpegProfile,
-                    new MediaVersion(),
-                    new MediaStream(),
-                    new MediaStream(),
-                    DateTimeOffset.Now,
-                    DateTimeOffset.Now,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    None);
-
-                actual.HardwareAcceleration.Should().Be(HardwareAccelerationKind.Qsv);
-            }
+            actual.ThreadCount.Should().Be(7);
         }
 
-        private static FFmpegProfile TestProfile() =>
-            new() { Resolution = new Resolution { Width = 1920, Height = 1080 } };
+        [Test]
+        public void Should_SetFormatFlags_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            string[] expected = { "+genpts", "+discardcorrupt", "+igndts" };
+            actual.FormatFlags.Count.Should().Be(expected.Length);
+            actual.FormatFlags.Should().Contain(expected);
+        }
+
+        [Test]
+        public void Should_SetFormatFlags_ForHttpLiveStreaming()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.HttpLiveStreamingDirect,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            string[] expected = { "+genpts", "+discardcorrupt", "+igndts" };
+            actual.FormatFlags.Count.Should().Be(expected.Length);
+            actual.FormatFlags.Should().Contain(expected);
+        }
+
+        [Test]
+        public void Should_SetRealtime_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.RealtimeOutput.Should().BeTrue();
+        }
+
+        [Test]
+        public void Should_SetRealtime_ForHttpLiveStreaming()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.HttpLiveStreamingDirect,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.RealtimeOutput.Should().BeTrue();
+        }
+
+        [Test]
+        public void Should_SetStreamSeek_When_PlaybackIsLate_ForTransportStream()
+        {
+            DateTimeOffset now = DateTimeOffset.Now;
+
+            FFmpegProfile ffmpegProfile = TestProfile();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                now,
+                now.AddMinutes(5),
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.StreamSeek.IsSome.Should().BeTrue();
+            actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
+        }
+
+        [Test]
+        public void Should_SetStreamSeek_When_PlaybackIsLate_ForHttpLiveStreaming()
+        {
+            DateTimeOffset now = DateTimeOffset.Now;
+
+            FFmpegProfile ffmpegProfile = TestProfile();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.HttpLiveStreamingDirect,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                now,
+                now.AddMinutes(5),
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.StreamSeek.IsSome.Should().BeTrue();
+            actual.StreamSeek.IfNone(TimeSpan.Zero).Should().Be(TimeSpan.FromMinutes(5));
+        }
+
+        [Test]
+        public void ShouldNot_SetScaledSize_When_NotNormalizingVideo_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with { NormalizeVideo = false };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+        }
+
+        [Test]
+        public void ShouldNot_SetScaledSize_When_ContentIsCorrectSize_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 }
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+        }
+
+        [Test]
+        public void ShouldNot_SetScaledSize_When_ScaledSizeWouldEqualContentSize_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 }
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+        }
+
+        [Test]
+        public void ShouldNot_PadToDesiredResolution_When_ContentIsCorrectSize_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 }
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+        }
+
+        [Test]
+        public void Should_PadToDesiredResolution_When_UnscaledContentIsUnderSized_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 }
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeTrue();
+        }
+
+        [Test]
+        public void Should_ScaleToEvenDimensions_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1280, Height = 720 }
+            };
+
+            var version = new MediaVersion { Width = 706, Height = 362, SampleAspectRatio = "32:27" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            IDisplaySize scaledSize = actual.ScaledSize.IfNone(new MediaVersion { Width = 0, Height = 0 });
+            scaledSize.Width.Should().Be(1280);
+            scaledSize.Height.Should().Be(554);
+            actual.PadToDesiredResolution.Should().BeTrue();
+        }
+
+        [Test]
+        public void Should_NotPadToDesiredResolution_When_UnscaledContentIsUnderSized_ForHttpLiveStreaming()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 }
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.HttpLiveStreamingDirect,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+        }
+
+        [Test]
+        public void Should_NotPadToDesiredResolution_When_NotNormalizingVideo()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeVideo = false,
+                Resolution = new Resolution { Width = 1920, Height = 1080 }
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+        }
+
+        [Test]
+        public void Should_SetDesiredVideoCodec_When_ContentIsPadded_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoCodec = "testCodec"
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeTrue();
+            actual.VideoCodec.Should().Be("testCodec");
+        }
+
+        [Test]
+        public void
+            Should_SetDesiredVideoCodec_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoCodec = "testCodec"
+            };
+
+            // not anamorphic
+            var version = new MediaVersion
+                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream { Codec = "mpeg2video" },
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+            actual.VideoCodec.Should().Be("testCodec");
+        }
+
+        [Test]
+        public void
+            Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NormalizingVideo_ForHttpLiveStreaming()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoCodec = "testCodec"
+            };
+
+            // not anamorphic
+            var version = new MediaVersion
+                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.HttpLiveStreamingDirect,
+                ffmpegProfile,
+                version,
+                new MediaStream { Codec = "mpeg2video" },
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+            actual.VideoCodec.Should().Be("copy");
+        }
+
+        [Test]
+        public void Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_CorrectCodec_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoCodec = "libx264"
+            };
+
+            // not anamorphic
+            var version = new MediaVersion
+                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream { Codec = "libx264" },
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+            actual.VideoCodec.Should().Be("copy");
+        }
+
+        [Test]
+        public void
+            Should_SetCopyVideoCodec_When_ContentIsCorrectSize_And_NotNormalizingVideo_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = false,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoCodec = "libx264"
+            };
+
+            // not anamorphic
+            var version = new MediaVersion
+                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream { Codec = "mpeg2video" },
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+            actual.VideoCodec.Should().Be("copy");
+        }
+            
+        [Test]
+        public void
+            Should_SetCopyVideoCodec_AndCopyAudioCodec_When_NotTranscoding_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = false,
+                NormalizeVideo = true,
+                NormalizeAudio = true,
+                NormalizeLoudness = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoCodec = "libx264"
+            };
+
+            // not anamorphic
+            var version = new MediaVersion
+                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream { Codec = "mpeg2video" },
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+            actual.VideoCodec.Should().Be("copy");
+            actual.NormalizeLoudness.Should().BeFalse();
+            actual.AudioCodec.Should().Be("copy");
+        }
+
+        [Test]
+        public void Should_SetVideoBitrate_When_ContentIsPadded_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoBitrate = 2525
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeTrue();
+            actual.VideoBitrate.IfNone(0).Should().Be(2525);
+        }
+
+        [Test]
+        public void Should_SetVideoBitrate_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoBitrate = 2525
+            };
+
+            // not anamorphic
+            var version = new MediaVersion
+                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream { Codec = "mpeg2video" },
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+            actual.VideoBitrate.IfNone(0).Should().Be(2525);
+        }
+
+        [Test]
+        public void Should_SetVideoBufferSize_When_ContentIsPadded_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoBufferSize = 2525
+            };
+
+            // not anamorphic
+            var version = new MediaVersion { Width = 1918, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeTrue();
+            actual.VideoBufferSize.IfNone(0).Should().Be(2525);
+        }
+
+        [Test]
+        public void
+            Should_SetVideoBufferSize_When_ContentIsCorrectSize_And_NormalizingVideo_ForTransportStream()
+        {
+            var ffmpegProfile = new FFmpegProfile
+            {
+                Transcode = true,
+                NormalizeVideo = true,
+                Resolution = new Resolution { Width = 1920, Height = 1080 },
+                VideoBufferSize = 2525
+            };
+
+            // not anamorphic
+            var version = new MediaVersion
+                { Width = 1920, Height = 1080, SampleAspectRatio = "1:1" };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream { Codec = "mpeg2video" },
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.ScaledSize.IsNone.Should().BeTrue();
+            actual.PadToDesiredResolution.Should().BeFalse();
+            actual.VideoBufferSize.IfNone(0).Should().Be(2525);
+        }
+
+        [Test]
+        public void Should_SetDesiredAudioCodec_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioCodec = "aac"
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "aac" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioCodec.Should().Be("aac");
+        }
+
+        [Test]
+        public void Should_SetCopyAudioCodec_When_NotNormalizingAudio_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                NormalizeAudio = false,
+                AudioCodec = "aac"
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioCodec.Should().Be("copy");
+        }
+
+        [Test]
+        public void Should_SetDesiredAudioCodec_When_NormalizingAudio_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioCodec = "aac"
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioCodec.Should().Be("aac");
+        }
+
+        [Test]
+        public void Should_SetCopyAudioCodec_When_NormalizingAudio_ForHttpLiveStreaming()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioCodec = "aac"
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.HttpLiveStreamingDirect,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioCodec.Should().Be("copy");
+        }
+
+        [Test]
+        public void Should_SetAudioBitrate_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioBitrate = 2424,
+                AudioCodec = "ac3"
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioBitrate.IfNone(0).Should().Be(2424);
+        }
+
+        [Test]
+        public void Should_SetAudioBufferSize_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioBufferSize = 2424,
+                AudioCodec = "ac3"
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioBufferSize.IfNone(0).Should().Be(2424);
+        }
+
+        [Test]
+        public void Should_SetAudioChannels_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioCodec = "ac3",
+                AudioChannels = 6
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioChannels.IfNone(0).Should().Be(6);
+        }
+
+        [Test]
+        public void Should_SetAudioSampleRate_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioCodec = "ac3",
+                AudioSampleRate = 48
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioSampleRate.IfNone(0).Should().Be(48);
+        }
+
+        [Test]
+        public void Should_SetAudioChannels_When_NormalizingAudio_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioChannels = 6
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioChannels.IfNone(0).Should().Be(6);
+        }
+
+        [Test]
+        public void Should_SetAudioSampleRate_When_NormalizingAudio_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioSampleRate = 48
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.AudioSampleRate.IfNone(0).Should().Be(48);
+        }
+
+        [Test]
+        public void Should_SetAudioDuration_When_NormalizingAudio_With_CorrectCodec_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                AudioSampleRate = 48,
+                AudioCodec = "ac3"
+            };
+
+            var version = new MediaVersion { Duration = TimeSpan.FromMinutes(5) }; // not pulled from here
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.FromMinutes(2),
+                false,
+                None);
+
+            actual.AudioDuration.IfNone(TimeSpan.MinValue).Should().Be(TimeSpan.FromMinutes(2));
+        }
+
+        [Test]
+        public void Should_SetNormalizeLoudness_When_NormalizingAudio_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = true,
+                NormalizeLoudness = true
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.NormalizeLoudness.Should().BeTrue();
+        }
+
+        [Test]
+        public void Should_NotSetNormalizeLoudness_When_NotNormalizingAudio_ForTransportStream()
+        {
+            FFmpegProfile ffmpegProfile = TestProfile() with
+            {
+                Transcode = true,
+                NormalizeAudio = false,
+                NormalizeLoudness = true
+            };
+
+            var version = new MediaVersion();
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                version,
+                new MediaStream(),
+                new MediaStream { Codec = "ac3" },
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.NormalizeLoudness.Should().BeFalse();
+        }
     }
-}
+
+    [TestFixture]
+    public class CalculateSettingsQsv
+    {
+        private readonly FFmpegPlaybackSettingsCalculator _calculator;
+
+        public CalculateSettingsQsv() => _calculator = new FFmpegPlaybackSettingsCalculator();
+
+        [Test]
+        public void Should_UseHardwareAcceleration()
+        {
+            FFmpegProfile ffmpegProfile =
+                TestProfile() with { HardwareAcceleration = HardwareAccelerationKind.Qsv };
+
+            FFmpegPlaybackSettings actual = _calculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                ffmpegProfile,
+                new MediaVersion(),
+                new MediaStream(),
+                new MediaStream(),
+                DateTimeOffset.Now,
+                DateTimeOffset.Now,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                None);
+
+            actual.HardwareAcceleration.Should().Be(HardwareAccelerationKind.Qsv);
+        }
+    }
+
+    private static FFmpegProfile TestProfile() =>
+        new() { Resolution = new Resolution { Width = 1920, Height = 1080 } };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs b/ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs
index 755e3d891..bda2c3acc 100644
--- a/ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/HlsPlaylistFilterTests.cs
@@ -1,32 +1,31 @@
-using System;
-using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using FluentAssertions;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.FFmpeg
+namespace ErsatzTV.Core.Tests.FFmpeg;
+
+[TestFixture]
+public class HlsPlaylistFilterTests
 {
-    [TestFixture]
-    public class HlsPlaylistFilterTests
+    private HlsPlaylistFilter _hlsPlaylistFilter;
+        
+    [SetUp]
+    public void SetUp()
     {
-        private HlsPlaylistFilter _hlsPlaylistFilter;
-        
-        [SetUp]
-        public void SetUp()
-        {
-            _hlsPlaylistFilter = new HlsPlaylistFilter(
-                new Mock<ITempFilePool>().Object,
-                new Mock<ILogger<HlsPlaylistFilter>>().Object
-            );
-        }
+        _hlsPlaylistFilter = new HlsPlaylistFilter(
+            new Mock<ITempFilePool>().Object,
+            new Mock<ILogger<HlsPlaylistFilter>>().Object
+        );
+    }
 
-        [Test]
-        public void _hlsPlaylistFilter_ShouldRewriteProgramDateTime()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldRewriteProgramDateTime()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -42,12 +41,12 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input);
 
-            result.PlaylistStart.Should().Be(start);
-            result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start);
+        result.Sequence.Should().Be(1137);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -64,13 +63,13 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
 "));
-        }
+    }
         
-        [Test]
-        public void _hlsPlaylistFilter_ShouldLimitSegments()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldLimitSegments()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -86,12 +85,12 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input, 2);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(-30), input, 2);
 
-            result.PlaylistStart.Should().Be(start);
-            result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start);
+        result.Sequence.Should().Be(1137);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -105,13 +104,13 @@ live001137.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:04.000-0500
 live001138.ts
 "));
-        }
+    }
         
-        [Test]
-        public void _hlsPlaylistFilter_ShouldAddDiscontinuity()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldAddDiscontinuity()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -127,17 +126,17 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(
-                start,
-                start.AddSeconds(-30),
-                input,
-                int.MaxValue,
-                true);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(
+            start,
+            start.AddSeconds(-30),
+            input,
+            int.MaxValue,
+            true);
 
-            result.PlaylistStart.Should().Be(start);
-            result.Sequence.Should().Be(1137);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start);
+        result.Sequence.Should().Be(1137);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -155,13 +154,13 @@ live001138.ts
 live001139.ts
 #EXT-X-DISCONTINUITY
 "));
-        }
+    }
 
-        [Test]
-        public void _hlsPlaylistFilter_ShouldFilterOldSegments()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldFilterOldSegments()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -177,12 +176,12 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
 
-            result.PlaylistStart.Should().Be(start.AddSeconds(8));
-            result.Sequence.Should().Be(1139);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start.AddSeconds(8));
+        result.Sequence.Should().Be(1139);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1139
@@ -193,13 +192,13 @@ live001139.ts").Split(Environment.NewLine);
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
 "));
-        }
+    }
         
-        [Test]
-        public void _hlsPlaylistFilter_ShouldFilterOldDiscontinuity()
-        {
-            var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
-            string[] input = NormalizeLineEndings(@"#EXTM3U
+    [Test]
+    public void _hlsPlaylistFilter_ShouldFilterOldDiscontinuity()
+    {
+        var start = new DateTimeOffset(2021, 10, 9, 8, 0, 0, TimeSpan.FromHours(-5));
+        string[] input = NormalizeLineEndings(@"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1137
@@ -216,12 +215,12 @@ live001138.ts
 #EXT-X-PROGRAM-DATE-TIME:2021-10-08T08:34:57.320-0500
 live001139.ts").Split(Environment.NewLine);
 
-            TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
+        TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(start, start.AddSeconds(6), input);
 
-            result.PlaylistStart.Should().Be(start.AddSeconds(8));
-            result.Sequence.Should().Be(1139);
-            result.Playlist.Should().Be(NormalizeLineEndings(
-                @"#EXTM3U
+        result.PlaylistStart.Should().Be(start.AddSeconds(8));
+        result.Sequence.Should().Be(1139);
+        result.Playlist.Should().Be(NormalizeLineEndings(
+            @"#EXTM3U
 #EXT-X-VERSION:6
 #EXT-X-TARGETDURATION:4
 #EXT-X-MEDIA-SEQUENCE:1139
@@ -232,14 +231,13 @@ live001139.ts").Split(Environment.NewLine);
 #EXT-X-PROGRAM-DATE-TIME:2021-10-09T08:00:08.000-0500
 live001139.ts
 "));
-        }
-
-        private static string NormalizeLineEndings(string str)
-        {
-            return str
-                .Replace("\r\n", "\n")
-                .Replace("\r", "\n")
-                .Replace("\n", Environment.NewLine);
-        }
     }
-}
+
+    private static string NormalizeLineEndings(string str)
+    {
+        return str
+            .Replace("\r\n", "\n")
+            .Replace("\r", "\n")
+            .Replace("\n", Environment.NewLine);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs b/ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs
index d50095749..92128e8e9 100644
--- a/ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/TranscodingTests.cs
@@ -1,12 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
+using System.Diagnostics;
 using System.Security.Cryptography;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.FFmpeg;
@@ -15,173 +9,171 @@ using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
 using FluentAssertions;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 using Serilog;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.FFmpeg
+namespace ErsatzTV.Core.Tests.FFmpeg;
+
+[TestFixture]
+[Explicit]
+public class TranscodingTests
 {
-    [TestFixture]
-    [Explicit]
-    public class TranscodingTests
-    {
-        private static readonly ILoggerFactory LoggerFactory;
+    private static readonly ILoggerFactory LoggerFactory;
         
-        static TranscodingTests()
-        {
-            Log.Logger = new LoggerConfiguration()
-                .MinimumLevel.Debug()
-                .WriteTo.Console()
-                .CreateLogger();
+    static TranscodingTests()
+    {
+        Log.Logger = new LoggerConfiguration()
+            .MinimumLevel.Debug()
+            .WriteTo.Console()
+            .CreateLogger();
 
-            LoggerFactory = new LoggerFactory().AddSerilog(Log.Logger);
+        LoggerFactory = new LoggerFactory().AddSerilog(Log.Logger);
+    }
+
+    [Test]
+    [Explicit]
+    public void DeleteTestVideos()
+    {
+        foreach (string file in Directory.GetFiles(TestContext.CurrentContext.TestDirectory, "*.mkv"))
+        {
+            File.Delete(file);
         }
 
-        [Test]
-        [Explicit]
-        public void DeleteTestVideos()
+        Assert.Pass();
+    }
+
+    public record InputFormat(string Encoder, string PixelFormat);
+
+    public enum Padding
+    {
+        NoPadding,
+        WithPadding
+    }
+
+    public enum Watermark
+    {
+        None,
+        PermanentOpaque,
+        PermanentTransparent,
+        IntermittentOpaque,
+        IntermittentTransparent
+        // TODO: animated vs static
+    }
+
+    private class TestData
+    {
+        public static Watermark[] Watermarks =
         {
-            foreach (string file in Directory.GetFiles(TestContext.CurrentContext.TestDirectory, "*.mkv"))
-            {
-                File.Delete(file);
-            }
-
-            Assert.Pass();
-        }
-
-        public record InputFormat(string Encoder, string PixelFormat);
-
-        public enum Padding
-        {
-            NoPadding,
-            WithPadding
-        }
-
-        public enum Watermark
-        {
-            None,
-            PermanentOpaque,
-            PermanentTransparent,
-            IntermittentOpaque,
-            IntermittentTransparent
-            // TODO: animated vs static
-        }
-
-        private class TestData
-        {
-            public static Watermark[] Watermarks =
-            {
-                Watermark.None,
-                Watermark.PermanentOpaque,
-                Watermark.PermanentTransparent
-            };
+            Watermark.None,
+            Watermark.PermanentOpaque,
+            Watermark.PermanentTransparent
+        };
             
-            public static Padding[] Paddings =
-            {
-                Padding.NoPadding,
-                Padding.WithPadding
-            };
+        public static Padding[] Paddings =
+        {
+            Padding.NoPadding,
+            Padding.WithPadding
+        };
 
-            public static VideoScanKind[] VideoScanKinds =
-            {
-                VideoScanKind.Progressive,
-                VideoScanKind.Interlaced
-            };
+        public static VideoScanKind[] VideoScanKinds =
+        {
+            VideoScanKind.Progressive,
+            VideoScanKind.Interlaced
+        };
 
-            public static InputFormat[] InputFormats =
-            {
-                new("libx264", "yuv420p"),
-                new("libx264", "yuvj420p"),
-                new("libx264", "yuv420p10le"),
-                // new("libx264", "yuv444p10le"),
+        public static InputFormat[] InputFormats =
+        {
+            new("libx264", "yuv420p"),
+            new("libx264", "yuvj420p"),
+            new("libx264", "yuv420p10le"),
+            // new("libx264", "yuv444p10le"),
 
-                new("mpeg1video", "yuv420p"),
+            new("mpeg1video", "yuv420p"),
 
-                new("mpeg2video", "yuv420p"),
+            new("mpeg2video", "yuv420p"),
 
-                new("libx265", "yuv420p"),
-                new("libx265", "yuv420p10le"),
+            new("libx265", "yuv420p"),
+            new("libx265", "yuv420p10le"),
 
-                new("mpeg4", "yuv420p"),
+            new("mpeg4", "yuv420p"),
 
-                new("libvpx-vp9", "yuv420p"),
+            new("libvpx-vp9", "yuv420p"),
 
-                // new("libaom-av1", "yuv420p")
-                // av1    yuv420p10le    51
+            // new("libaom-av1", "yuv420p")
+            // av1    yuv420p10le    51
 
-                new("msmpeg4v2", "yuv420p"),
-                new("msmpeg4v3", "yuv420p")
+            new("msmpeg4v2", "yuv420p"),
+            new("msmpeg4v3", "yuv420p")
 
-                // wmv3    yuv420p    1
-            };
+            // wmv3    yuv420p    1
+        };
             
-            public static Resolution[] Resolutions =
-            {
-                new() { Width = 1920, Height = 1080 },
-                new() { Width = 1280, Height = 720 }
-            };
+        public static Resolution[] Resolutions =
+        {
+            new() { Width = 1920, Height = 1080 },
+            new() { Width = 1280, Height = 720 }
+        };
 
-            public static string[] SoftwareCodecs =
-            {
-                "libx264",
-                "libx265"
-            };
+        public static string[] SoftwareCodecs =
+        {
+            "libx264",
+            "libx265"
+        };
 
-            public static HardwareAccelerationKind[] NoAcceleration =
-            {
-                HardwareAccelerationKind.None
-            };
+        public static HardwareAccelerationKind[] NoAcceleration =
+        {
+            HardwareAccelerationKind.None
+        };
 
-            public static string[] NvidiaCodecs =
-            {
-                "h264_nvenc",
-                "hevc_nvenc"
-            };
+        public static string[] NvidiaCodecs =
+        {
+            "h264_nvenc",
+            "hevc_nvenc"
+        };
 
-            public static HardwareAccelerationKind[] NvidiaAcceleration =
-            {
-                HardwareAccelerationKind.Nvenc
-            };
+        public static HardwareAccelerationKind[] NvidiaAcceleration =
+        {
+            HardwareAccelerationKind.Nvenc
+        };
 
-            public static string[] VaapiCodecs =
-            {
-                "h264_vaapi",
-                "hevc_vaapi"
-            };
+        public static string[] VaapiCodecs =
+        {
+            "h264_vaapi",
+            "hevc_vaapi"
+        };
 
-            public static HardwareAccelerationKind[] VaapiAcceleration =
-            {
-                HardwareAccelerationKind.Vaapi
-            };
+        public static HardwareAccelerationKind[] VaapiAcceleration =
+        {
+            HardwareAccelerationKind.Vaapi
+        };
 
-            public static string[] VideoToolboxCodecs =
-            {
-                "h264_videotoolbox",
-                "hevc_videotoolbox"
-            };
+        public static string[] VideoToolboxCodecs =
+        {
+            "h264_videotoolbox",
+            "hevc_videotoolbox"
+        };
 
-            public static HardwareAccelerationKind[] VideoToolboxAcceleration =
-            {
-                HardwareAccelerationKind.VideoToolbox
-            };
+        public static HardwareAccelerationKind[] VideoToolboxAcceleration =
+        {
+            HardwareAccelerationKind.VideoToolbox
+        };
 
-            public static string[] QsvCodecs =
-            {
-                "h264_qsv",
-                "hevc_qsv"
-            };
+        public static string[] QsvCodecs =
+        {
+            "h264_qsv",
+            "hevc_qsv"
+        };
 
-            public static HardwareAccelerationKind[] QsvAcceleration =
-            {
-                HardwareAccelerationKind.Qsv
-            };
-        }
+        public static HardwareAccelerationKind[] QsvAcceleration =
+        {
+            HardwareAccelerationKind.Qsv
+        };
+    }
 
-        [Test, Combinatorial]
-        public async Task Transcode(
+    [Test, Combinatorial]
+    public async Task Transcode(
             [ValueSource(typeof(TestData), nameof(TestData.InputFormats))]
             InputFormat inputFormat,
             [ValueSource(typeof(TestData), nameof(TestData.Resolutions))]
@@ -196,280 +188,279 @@ namespace ErsatzTV.Core.Tests.FFmpeg
             // [ValueSource(typeof(TestData), nameof(TestData.NoAcceleration))] HardwareAccelerationKind profileAcceleration)
             [ValueSource(typeof(TestData), nameof(TestData.NvidiaCodecs))] string profileCodec,
             [ValueSource(typeof(TestData), nameof(TestData.NvidiaAcceleration))] HardwareAccelerationKind profileAcceleration)
-            // [ValueSource(typeof(TestData), nameof(TestData.VaapiCodecs))] string profileCodec,
-            // [ValueSource(typeof(TestData), nameof(TestData.VaapiAcceleration))] HardwareAccelerationKind profileAcceleration)
-            // [ValueSource(typeof(TestData), nameof(TestData.QsvCodecs))] string profileCodec,
-            // [ValueSource(typeof(TestData), nameof(TestData.QsvAcceleration))] HardwareAccelerationKind profileAcceleration)
-            // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxCodecs))] string profileCodec,
-            // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxAcceleration))] HardwareAccelerationKind profileAcceleration)
+        // [ValueSource(typeof(TestData), nameof(TestData.VaapiCodecs))] string profileCodec,
+        // [ValueSource(typeof(TestData), nameof(TestData.VaapiAcceleration))] HardwareAccelerationKind profileAcceleration)
+        // [ValueSource(typeof(TestData), nameof(TestData.QsvCodecs))] string profileCodec,
+        // [ValueSource(typeof(TestData), nameof(TestData.QsvAcceleration))] HardwareAccelerationKind profileAcceleration)
+        // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxCodecs))] string profileCodec,
+        // [ValueSource(typeof(TestData), nameof(TestData.VideoToolboxAcceleration))] HardwareAccelerationKind profileAcceleration)
+    {
+        if (inputFormat.Encoder is "mpeg1video" or "msmpeg4v2" or "msmpeg4v3")
         {
-            if (inputFormat.Encoder is "mpeg1video" or "msmpeg4v2" or "msmpeg4v3")
+            if (videoScanKind == VideoScanKind.Interlaced)
             {
-                if (videoScanKind == VideoScanKind.Interlaced)
-                {
-                    Assert.Inconclusive($"{inputFormat.Encoder} does not support interlaced content");
-                    return;
-                }
-            }
-
-            string name = GetStringSha256Hash(
-                $"{inputFormat.Encoder}_{inputFormat.PixelFormat}_{videoScanKind}_{padding}_{profileResolution}_{profileCodec}_{profileAcceleration}");
-
-            string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
-            if (!File.Exists(file))
-            {
-                string resolution = padding == Padding.WithPadding ? "1920x1060" : "1920x1080";
-
-                string videoFilter = videoScanKind == VideoScanKind.Interlaced ? "-vf tinterlace=interleave_top,fieldorder=tff" : string.Empty;
-                string flags = videoScanKind == VideoScanKind.Interlaced ? "-flags +ildct+ilme" : string.Empty;
-                
-                string args =
-                    $"-y -f lavfi -i anoisesrc=color=brown -f lavfi -i testsrc=duration=1:size={resolution}:rate=30 {videoFilter} -c:a aac -c:v {inputFormat.Encoder} -shortest -pix_fmt {inputFormat.PixelFormat} -strict -2 {flags} {file}";
-                var p1 = new Process
-                {
-                    StartInfo = new ProcessStartInfo
-                    {
-                        FileName = ExecutableName("ffmpeg"),
-                        Arguments = args
-                    }
-                };
-
-                p1.Start();
-                await p1.WaitForExitAsync();
-                // ReSharper disable once MethodHasAsyncOverload
-                p1.WaitForExit();
-                p1.ExitCode.Should().Be(0);
-            }
-
-            var imageCache = new Mock<IImageCache>();
-            
-            // always return the static watermark resource
-            imageCache.Setup(
-                    ic => ic.GetPathForImage(
-                        It.IsAny<string>(),
-                        It.Is<ArtworkKind>(x => x == ArtworkKind.Watermark),
-                        It.IsAny<Option<int>>()))
-                .Returns(Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "ErsatzTV.png"));
-
-            var oldService = new FFmpegProcessService(
-                new FFmpegPlaybackSettingsCalculator(),
-                new FakeStreamSelector(),
-                imageCache.Object,
-                new Mock<ITempFilePool>().Object,
-                LoggerFactory.CreateLogger<FFmpegProcessService>());
-
-            var service = new FFmpegLibraryProcessService(
-                oldService,
-                new FFmpegPlaybackSettingsCalculator(),
-                new FakeStreamSelector(),
-                LoggerFactory.CreateLogger<FFmpegLibraryProcessService>());
-
-            var v = new MediaVersion
-            {
-                MediaFiles = new List<MediaFile>
-                {
-                    new() { Path = file }
-                }
-            };
-
-            var metadataRepository = new Mock<IMetadataRepository>();
-            metadataRepository
-                .Setup(r => r.UpdateLocalStatistics(It.IsAny<MediaItem>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
-                .Callback<MediaItem, MediaVersion, bool>((_, version, _) =>
-                {
-                    version.MediaFiles = v.MediaFiles;
-                    v = version;
-                });
-
-            var localStatisticsProvider = new LocalStatisticsProvider(
-                metadataRepository.Object,
-                new LocalFileSystem(LoggerFactory.CreateLogger<LocalFileSystem>()),
-                LoggerFactory.CreateLogger<LocalStatisticsProvider>());
-
-            await localStatisticsProvider.RefreshStatistics(
-                ExecutableName("ffprobe"),
-                new Movie
-                {
-                    MediaVersions = new List<MediaVersion>
-                    {
-                        new()
-                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = file }
-                            }
-                        }
-                    }
-                });
-
-            DateTimeOffset now = DateTimeOffset.Now;
-
-            Option<ChannelWatermark> channelWatermark = Option<ChannelWatermark>.None;
-            switch (watermark)
-            {
-                case Watermark.None:
-                    break;
-                case Watermark.IntermittentOpaque:
-                    channelWatermark = new ChannelWatermark
-                    {
-                        ImageSource = ChannelWatermarkImageSource.Custom,
-                        Mode = ChannelWatermarkMode.Intermittent,
-                        // TODO: how do we make sure this actually appears
-                        FrequencyMinutes = 1,
-                        DurationSeconds = 2,
-                        Opacity = 100
-                    };
-                    break;
-                case Watermark.IntermittentTransparent:
-                    channelWatermark = new ChannelWatermark
-                    {
-                        ImageSource = ChannelWatermarkImageSource.Custom,
-                        Mode = ChannelWatermarkMode.Intermittent,
-                        // TODO: how do we make sure this actually appears
-                        FrequencyMinutes = 1,
-                        DurationSeconds = 2,
-                        Opacity = 80
-                    };
-                    break;
-                case Watermark.PermanentOpaque:
-                    channelWatermark = new ChannelWatermark
-                    {
-                        ImageSource = ChannelWatermarkImageSource.Custom,
-                        Mode = ChannelWatermarkMode.Permanent,
-                        Opacity = 100
-                    };
-                    break;
-                case Watermark.PermanentTransparent:
-                    channelWatermark = new ChannelWatermark
-                    {
-                        ImageSource = ChannelWatermarkImageSource.Custom,
-                        Mode = ChannelWatermarkMode.Permanent,
-                        Opacity = 80
-                    };
-                    break;
-            }
-
-            Process process = await service.ForPlayoutItem(
-                ExecutableName("ffmpeg"),
-                false,
-                new Channel(Guid.NewGuid())
-                {
-                    Number = "1",
-                    FFmpegProfile = FFmpegProfile.New("test", profileResolution) with
-                    {
-                        HardwareAcceleration = profileAcceleration,
-                        VideoCodec = profileCodec,
-                        AudioCodec = "aac"
-                    },
-                    StreamingMode = StreamingMode.TransportStream
-                },
-                v,
-                v,
-                file,
-                file,
-                now,
-                now + TimeSpan.FromSeconds(5),
-                now,
-                channelWatermark,
-                VaapiDriver.Default,
-                "/dev/dri/renderD128",
-                false,
-                FillerKind.None,
-                TimeSpan.Zero,
-                TimeSpan.FromSeconds(5),
-                0,
-                None);
-
-            process.StartInfo.RedirectStandardError = true;
-            process.EnableRaisingEvents = true;
-            
-            // Console.WriteLine($"ffmpeg arguments {string.Join(" ", process.StartInfo.ArgumentList)}");
-
-            process.Start().Should().BeTrue();
-
-            string[] unsupportedMessages =
-            {
-                "No support for codec",
-                "No usable",
-                "Provided device doesn't support"
-            };
-
-            var errorBuffer = new StringBuilder();
-            
-            process.ErrorDataReceived += (_, errorLine) =>
-            {
-                string data = errorLine.Data ?? string.Empty;
-                errorBuffer.AppendLine(data);
-            };
-
-            process.BeginOutputReadLine();
-            process.BeginErrorReadLine();
-            // string error = await process.StandardError.ReadToEndAsync();
-
-            var timeoutSignal = new CancellationTokenSource(TimeSpan.FromSeconds(30));
-            try
-            {
-                await process.WaitForExitAsync(timeoutSignal.Token);
-                // ReSharper disable once MethodHasAsyncOverload
-                process.WaitForExit();
-            }
-            catch (OperationCanceledException)
-            {
-                process.Kill();
-
-                IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
-                Assert.Fail($"Transcode failure (timeout): ffmpeg {string.Join(" ", quotedArgs)}");
+                Assert.Inconclusive($"{inputFormat.Encoder} does not support interlaced content");
                 return;
             }
+        }
 
-            var error = errorBuffer.ToString();
-            bool isUnsupported = unsupportedMessages.Any(error.Contains); 
+        string name = GetStringSha256Hash(
+            $"{inputFormat.Encoder}_{inputFormat.PixelFormat}_{videoScanKind}_{padding}_{profileResolution}_{profileCodec}_{profileAcceleration}");
 
-            if (profileAcceleration != HardwareAccelerationKind.None && isUnsupported)
+        string file = Path.Combine(TestContext.CurrentContext.TestDirectory, $"{name}.mkv");
+        if (!File.Exists(file))
+        {
+            string resolution = padding == Padding.WithPadding ? "1920x1060" : "1920x1080";
+
+            string videoFilter = videoScanKind == VideoScanKind.Interlaced ? "-vf tinterlace=interleave_top,fieldorder=tff" : string.Empty;
+            string flags = videoScanKind == VideoScanKind.Interlaced ? "-flags +ildct+ilme" : string.Empty;
+                
+            string args =
+                $"-y -f lavfi -i anoisesrc=color=brown -f lavfi -i testsrc=duration=1:size={resolution}:rate=30 {videoFilter} -c:a aac -c:v {inputFormat.Encoder} -shortest -pix_fmt {inputFormat.PixelFormat} -strict -2 {flags} {file}";
+            var p1 = new Process
             {
-                var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
-                process.ExitCode.Should().Be(1, $"Error message with successful exit code? {string.Join(" ", quotedArgs)}");
-                Assert.Warn($"Unsupported on this hardware: ffmpeg {string.Join(" ", quotedArgs)}");
-            }
-            else if (error.Contains("Impossible to convert between"))
-            {
-                IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
-                Assert.Fail($"Transcode failure: ffmpeg {string.Join(" ", quotedArgs)}");
-            }
-            else
-            {
-                var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
-                process.ExitCode.Should().Be(0, errorBuffer + Environment.NewLine + string.Join(" ", quotedArgs));
-                if (process.ExitCode == 0)
+                StartInfo = new ProcessStartInfo
                 {
-                    Console.WriteLine(string.Join(" ", quotedArgs));
+                    FileName = ExecutableName("ffmpeg"),
+                    Arguments = args
                 }
-            }
+            };
+
+            p1.Start();
+            await p1.WaitForExitAsync();
+            // ReSharper disable once MethodHasAsyncOverload
+            p1.WaitForExit();
+            p1.ExitCode.Should().Be(0);
         }
-        
-        private static string GetStringSha256Hash(string text)
+
+        var imageCache = new Mock<IImageCache>();
+            
+        // always return the static watermark resource
+        imageCache.Setup(
+                ic => ic.GetPathForImage(
+                    It.IsAny<string>(),
+                    It.Is<ArtworkKind>(x => x == ArtworkKind.Watermark),
+                    It.IsAny<Option<int>>()))
+            .Returns(Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "ErsatzTV.png"));
+
+        var oldService = new FFmpegProcessService(
+            new FFmpegPlaybackSettingsCalculator(),
+            new FakeStreamSelector(),
+            imageCache.Object,
+            new Mock<ITempFilePool>().Object,
+            LoggerFactory.CreateLogger<FFmpegProcessService>());
+
+        var service = new FFmpegLibraryProcessService(
+            oldService,
+            new FFmpegPlaybackSettingsCalculator(),
+            new FakeStreamSelector(),
+            LoggerFactory.CreateLogger<FFmpegLibraryProcessService>());
+
+        var v = new MediaVersion
         {
-            if (string.IsNullOrEmpty(text))
+            MediaFiles = new List<MediaFile>
             {
-                return string.Empty;
+                new() { Path = file }
             }
+        };
 
-            using var sha = SHA256.Create();
-            byte[] textData = Encoding.UTF8.GetBytes(text);
-            byte[] hash = sha.ComputeHash(textData);
-            return BitConverter.ToString(hash).Replace("-", string.Empty);
-        }
+        var metadataRepository = new Mock<IMetadataRepository>();
+        metadataRepository
+            .Setup(r => r.UpdateLocalStatistics(It.IsAny<MediaItem>(), It.IsAny<MediaVersion>(), It.IsAny<bool>()))
+            .Callback<MediaItem, MediaVersion, bool>((_, version, _) =>
+            {
+                version.MediaFiles = v.MediaFiles;
+                v = version;
+            });
 
-        private class FakeStreamSelector : IFFmpegStreamSelector
+        var localStatisticsProvider = new LocalStatisticsProvider(
+            metadataRepository.Object,
+            new LocalFileSystem(LoggerFactory.CreateLogger<LocalFileSystem>()),
+            LoggerFactory.CreateLogger<LocalStatisticsProvider>());
+
+        await localStatisticsProvider.RefreshStatistics(
+            ExecutableName("ffprobe"),
+            new Movie
+            {
+                MediaVersions = new List<MediaVersion>
+                {
+                    new()
+                    {
+                        MediaFiles = new List<MediaFile>
+                        {
+                            new() { Path = file }
+                        }
+                    }
+                }
+            });
+
+        DateTimeOffset now = DateTimeOffset.Now;
+
+        Option<ChannelWatermark> channelWatermark = Option<ChannelWatermark>.None;
+        switch (watermark)
         {
-            public Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version) =>
-                version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Video).AsTask();
-
-            public Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version) =>
-                Optional(version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Audio)).AsTask();
+            case Watermark.None:
+                break;
+            case Watermark.IntermittentOpaque:
+                channelWatermark = new ChannelWatermark
+                {
+                    ImageSource = ChannelWatermarkImageSource.Custom,
+                    Mode = ChannelWatermarkMode.Intermittent,
+                    // TODO: how do we make sure this actually appears
+                    FrequencyMinutes = 1,
+                    DurationSeconds = 2,
+                    Opacity = 100
+                };
+                break;
+            case Watermark.IntermittentTransparent:
+                channelWatermark = new ChannelWatermark
+                {
+                    ImageSource = ChannelWatermarkImageSource.Custom,
+                    Mode = ChannelWatermarkMode.Intermittent,
+                    // TODO: how do we make sure this actually appears
+                    FrequencyMinutes = 1,
+                    DurationSeconds = 2,
+                    Opacity = 80
+                };
+                break;
+            case Watermark.PermanentOpaque:
+                channelWatermark = new ChannelWatermark
+                {
+                    ImageSource = ChannelWatermarkImageSource.Custom,
+                    Mode = ChannelWatermarkMode.Permanent,
+                    Opacity = 100
+                };
+                break;
+            case Watermark.PermanentTransparent:
+                channelWatermark = new ChannelWatermark
+                {
+                    ImageSource = ChannelWatermarkImageSource.Custom,
+                    Mode = ChannelWatermarkMode.Permanent,
+                    Opacity = 80
+                };
+                break;
         }
 
-        private static string ExecutableName(string baseName) =>
-            OperatingSystem.IsWindows() ? $"{baseName}.exe" : baseName;
+        Process process = await service.ForPlayoutItem(
+            ExecutableName("ffmpeg"),
+            false,
+            new Channel(Guid.NewGuid())
+            {
+                Number = "1",
+                FFmpegProfile = FFmpegProfile.New("test", profileResolution) with
+                {
+                    HardwareAcceleration = profileAcceleration,
+                    VideoCodec = profileCodec,
+                    AudioCodec = "aac"
+                },
+                StreamingMode = StreamingMode.TransportStream
+            },
+            v,
+            v,
+            file,
+            file,
+            now,
+            now + TimeSpan.FromSeconds(5),
+            now,
+            channelWatermark,
+            VaapiDriver.Default,
+            "/dev/dri/renderD128",
+            false,
+            FillerKind.None,
+            TimeSpan.Zero,
+            TimeSpan.FromSeconds(5),
+            0,
+            None);
+
+        process.StartInfo.RedirectStandardError = true;
+        process.EnableRaisingEvents = true;
+            
+        // Console.WriteLine($"ffmpeg arguments {string.Join(" ", process.StartInfo.ArgumentList)}");
+
+        process.Start().Should().BeTrue();
+
+        string[] unsupportedMessages =
+        {
+            "No support for codec",
+            "No usable",
+            "Provided device doesn't support"
+        };
+
+        var errorBuffer = new StringBuilder();
+            
+        process.ErrorDataReceived += (_, errorLine) =>
+        {
+            string data = errorLine.Data ?? string.Empty;
+            errorBuffer.AppendLine(data);
+        };
+
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
+        // string error = await process.StandardError.ReadToEndAsync();
+
+        var timeoutSignal = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        try
+        {
+            await process.WaitForExitAsync(timeoutSignal.Token);
+            // ReSharper disable once MethodHasAsyncOverload
+            process.WaitForExit();
+        }
+        catch (OperationCanceledException)
+        {
+            process.Kill();
+
+            IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
+            Assert.Fail($"Transcode failure (timeout): ffmpeg {string.Join(" ", quotedArgs)}");
+            return;
+        }
+
+        var error = errorBuffer.ToString();
+        bool isUnsupported = unsupportedMessages.Any(error.Contains); 
+
+        if (profileAcceleration != HardwareAccelerationKind.None && isUnsupported)
+        {
+            var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
+            process.ExitCode.Should().Be(1, $"Error message with successful exit code? {string.Join(" ", quotedArgs)}");
+            Assert.Warn($"Unsupported on this hardware: ffmpeg {string.Join(" ", quotedArgs)}");
+        }
+        else if (error.Contains("Impossible to convert between"))
+        {
+            IEnumerable<string> quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'");
+            Assert.Fail($"Transcode failure: ffmpeg {string.Join(" ", quotedArgs)}");
+        }
+        else
+        {
+            var quotedArgs = process.StartInfo.ArgumentList.Map(a => $"\'{a}\'").ToList();
+            process.ExitCode.Should().Be(0, errorBuffer + Environment.NewLine + string.Join(" ", quotedArgs));
+            if (process.ExitCode == 0)
+            {
+                Console.WriteLine(string.Join(" ", quotedArgs));
+            }
+        }
     }
-}
+        
+    private static string GetStringSha256Hash(string text)
+    {
+        if (string.IsNullOrEmpty(text))
+        {
+            return string.Empty;
+        }
+
+        using var sha = SHA256.Create();
+        byte[] textData = Encoding.UTF8.GetBytes(text);
+        byte[] hash = sha.ComputeHash(textData);
+        return BitConverter.ToString(hash).Replace("-", string.Empty);
+    }
+
+    private class FakeStreamSelector : IFFmpegStreamSelector
+    {
+        public Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version) =>
+            version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Video).AsTask();
+
+        public Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version) =>
+            Optional(version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Audio)).AsTask();
+    }
+
+    private static string ExecutableName(string baseName) =>
+        OperatingSystem.IsWindows() ? $"{baseName}.exe" : baseName;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/FFmpeg/WatermarkCalculatorTests.cs b/ErsatzTV.Core.Tests/FFmpeg/WatermarkCalculatorTests.cs
index c5fa2aa47..5190324e0 100644
--- a/ErsatzTV.Core.Tests/FFmpeg/WatermarkCalculatorTests.cs
+++ b/ErsatzTV.Core.Tests/FFmpeg/WatermarkCalculatorTests.cs
@@ -1,9 +1,6 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.FFmpeg;
+using ErsatzTV.Core.FFmpeg;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.Core.Tests.FFmpeg;
 
diff --git a/ErsatzTV.Core.Tests/Fakes/FakeFileEntry.cs b/ErsatzTV.Core.Tests/Fakes/FakeFileEntry.cs
index fa02434ae..480aff0e4 100644
--- a/ErsatzTV.Core.Tests/Fakes/FakeFileEntry.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeFileEntry.cs
@@ -1,9 +1,6 @@
-using System;
+namespace ErsatzTV.Core.Tests.Fakes;
 
-namespace ErsatzTV.Core.Tests.Fakes
+public record FakeFileEntry(string Path)
 {
-    public record FakeFileEntry(string Path)
-    {
-        public DateTime LastWriteTime { get; set; } = SystemTime.MinValueUtc;
-    }
-}
+    public DateTime LastWriteTime { get; set; } = SystemTime.MinValueUtc;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Fakes/FakeFolderEntry.cs b/ErsatzTV.Core.Tests/Fakes/FakeFolderEntry.cs
index 3fbe5da0a..a2258c6c1 100644
--- a/ErsatzTV.Core.Tests/Fakes/FakeFolderEntry.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeFolderEntry.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Core.Tests.Fakes
-{
-    public record FakeFolderEntry(string Path);
-}
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public record FakeFolderEntry(string Path);
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs b/ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs
index 7a787e70a..7a9561125 100644
--- a/ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeLocalFileSystem.cs
@@ -1,83 +1,75 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.Fakes
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public class FakeLocalFileSystem : ILocalFileSystem
 {
-    public class FakeLocalFileSystem : ILocalFileSystem
+    public static readonly byte[] TestBytes = { 1, 2, 3, 4, 5 };
+
+    private readonly List<FakeFileEntry> _files;
+    private readonly List<FakeFolderEntry> _folders;
+
+    public FakeLocalFileSystem(List<FakeFileEntry> files) : this(files, new List<FakeFolderEntry>())
     {
-        public static readonly byte[] TestBytes = { 1, 2, 3, 4, 5 };
+    }
 
-        private readonly List<FakeFileEntry> _files;
-        private readonly List<FakeFolderEntry> _folders;
+    public FakeLocalFileSystem(List<FakeFileEntry> files, List<FakeFolderEntry> folders)
+    {
+        _files = files;
 
-        public FakeLocalFileSystem(List<FakeFileEntry> files) : this(files, new List<FakeFolderEntry>())
+        var allFolders = new List<string>(folders.Map(f => f.Path));
+        foreach (FakeFileEntry file in _files)
         {
+            List<DirectoryInfo> moreFolders =
+                Split(new DirectoryInfo(Path.GetDirectoryName(file.Path) ?? string.Empty));
+            allFolders.AddRange(moreFolders.Map(i => i.FullName));
         }
 
-        public FakeLocalFileSystem(List<FakeFileEntry> files, List<FakeFolderEntry> folders)
+        _folders = allFolders.Distinct().Map(f => new FakeFolderEntry(f)).ToList();
+    }
+
+    public Unit EnsureFolderExists(string folder) => Unit.Default;
+
+    public DateTime GetLastWriteTime(string path) =>
+        Optional(_files.SingleOrDefault(f => f.Path == path))
+            .Map(f => f.LastWriteTime)
+            .IfNone(SystemTime.MinValueUtc);
+
+    public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
+        _folders.Any(f => f.Path == libraryPath.Path);
+
+    public IEnumerable<string> ListSubdirectories(string folder) =>
+        _folders.Map(f => f.Path).Filter(f => f.StartsWith(folder) && Directory.GetParent(f)?.FullName == folder);
+
+    public IEnumerable<string> ListFiles(string folder) =>
+        _files.Map(f => f.Path).Filter(f => Path.GetDirectoryName(f) == folder);
+
+    public bool FileExists(string path) => _files.Any(f => f.Path == path);
+    public bool FolderExists(string folder) => false;
+
+    public Task<byte[]> ReadAllBytes(string path) => TestBytes.AsTask();
+
+    public Task<Either<BaseError, Unit>> CopyFile(string source, string destination) =>
+        Task.FromResult(Right<BaseError, Unit>(Unit.Default));
+
+    public Unit EmptyFolder(string folder) => Unit.Default;
+
+    private static List<DirectoryInfo> Split(DirectoryInfo path)
+    {
+        var result = new List<DirectoryInfo>();
+        if (path == null || string.IsNullOrWhiteSpace(path.FullName))
         {
-            _files = files;
-
-            var allFolders = new List<string>(folders.Map(f => f.Path));
-            foreach (FakeFileEntry file in _files)
-            {
-                List<DirectoryInfo> moreFolders =
-                    Split(new DirectoryInfo(Path.GetDirectoryName(file.Path) ?? string.Empty));
-                allFolders.AddRange(moreFolders.Map(i => i.FullName));
-            }
-
-            _folders = allFolders.Distinct().Map(f => new FakeFolderEntry(f)).ToList();
-        }
-
-        public Unit EnsureFolderExists(string folder) => Unit.Default;
-
-        public DateTime GetLastWriteTime(string path) =>
-            Optional(_files.SingleOrDefault(f => f.Path == path))
-                .Map(f => f.LastWriteTime)
-                .IfNone(SystemTime.MinValueUtc);
-
-        public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
-            _folders.Any(f => f.Path == libraryPath.Path);
-
-        public IEnumerable<string> ListSubdirectories(string folder) =>
-            _folders.Map(f => f.Path).Filter(f => f.StartsWith(folder) && Directory.GetParent(f)?.FullName == folder);
-
-        public IEnumerable<string> ListFiles(string folder) =>
-            _files.Map(f => f.Path).Filter(f => Path.GetDirectoryName(f) == folder);
-
-        public bool FileExists(string path) => _files.Any(f => f.Path == path);
-        public bool FolderExists(string folder) => false;
-
-        public Task<byte[]> ReadAllBytes(string path) => TestBytes.AsTask();
-
-        public Task<Either<BaseError, Unit>> CopyFile(string source, string destination) =>
-            Task.FromResult(Right<BaseError, Unit>(Unit.Default));
-
-        public Unit EmptyFolder(string folder) => Unit.Default;
-
-        private static List<DirectoryInfo> Split(DirectoryInfo path)
-        {
-            var result = new List<DirectoryInfo>();
-            if (path == null || string.IsNullOrWhiteSpace(path.FullName))
-            {
-                return result;
-            }
-
-            if (path.Parent != null)
-            {
-                result.AddRange(Split(path.Parent));
-            }
-
-            result.Add(path);
-
             return result;
         }
+
+        if (path.Parent != null)
+        {
+            result.AddRange(Split(path.Parent));
+        }
+
+        result.Add(path);
+
+        return result;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs b/ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs
index 697075492..6c03cd6e7 100644
--- a/ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeMediaCollectionRepository.cs
@@ -1,42 +1,36 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Scheduling;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Tests.Fakes
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public class FakeMediaCollectionRepository : IMediaCollectionRepository
 {
-    public class FakeMediaCollectionRepository : IMediaCollectionRepository
-    {
-        private readonly Map<int, List<MediaItem>> _data;
+    private readonly Map<int, List<MediaItem>> _data;
 
-        public FakeMediaCollectionRepository(Map<int, List<MediaItem>> data) => _data = data;
+    public FakeMediaCollectionRepository(Map<int, List<MediaItem>> data) => _data = data;
 
-        public Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id) =>
-            throw new NotSupportedException();
+    public Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id) =>
+        throw new NotSupportedException();
 
-        public Task<List<MediaItem>> GetItems(int id) => _data[id].ToList().AsTask();
-        public Task<List<MediaItem>> GetMultiCollectionItems(int id) => throw new NotSupportedException();
-        public Task<List<MediaItem>> GetSmartCollectionItems(int id) => throw new NotSupportedException();
+    public Task<List<MediaItem>> GetItems(int id) => _data[id].ToList().AsTask();
+    public Task<List<MediaItem>> GetMultiCollectionItems(int id) => throw new NotSupportedException();
+    public Task<List<MediaItem>> GetSmartCollectionItems(int id) => throw new NotSupportedException();
 
-        public Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id) =>
-            throw new NotSupportedException();
+    public Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id) =>
+        throw new NotSupportedException();
 
-        public Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(int? collectionId, int? smartCollectionId) =>
-            throw new NotSupportedException();
+    public Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(int? collectionId, int? smartCollectionId) =>
+        throw new NotSupportedException();
 
-        public Task<List<int>> PlayoutIdsUsingCollection(int collectionId) => throw new NotSupportedException();
+    public Task<List<int>> PlayoutIdsUsingCollection(int collectionId) => throw new NotSupportedException();
 
-        public Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId) =>
-            throw new NotSupportedException();
+    public Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId) =>
+        throw new NotSupportedException();
 
-        public Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId) =>
-            throw new NotSupportedException();
+    public Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId) =>
+        throw new NotSupportedException();
 
-        public Task<bool> IsCustomPlaybackOrder(int collectionId) => false.AsTask();
-        public Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection) => Option<string>.None.AsTask();
-    }
-}
+    public Task<bool> IsCustomPlaybackOrder(int collectionId) => false.AsTask();
+    public Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection) => Option<string>.None.AsTask();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Fakes/FakeMovieWithPath.cs b/ErsatzTV.Core.Tests/Fakes/FakeMovieWithPath.cs
index b4eb8e941..5a028745b 100644
--- a/ErsatzTV.Core.Tests/Fakes/FakeMovieWithPath.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeMovieWithPath.cs
@@ -1,26 +1,24 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
 
-namespace ErsatzTV.Core.Tests.Fakes
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public class FakeMovieWithPath : MediaItemScanResult<Movie>
 {
-    public class FakeMovieWithPath : MediaItemScanResult<Movie>
-    {
-        public FakeMovieWithPath(string path)
-            : base(
-                new Movie
+    public FakeMovieWithPath(string path)
+        : base(
+            new Movie
+            {
+                MediaVersions = new List<MediaVersion>
                 {
-                    MediaVersions = new List<MediaVersion>
+                    new()
                     {
-                        new()
+                        MediaFiles = new List<MediaFile>
                         {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            }
+                            new() { Path = path }
                         }
                     }
-                }) =>
-            IsAdded = true;
-    }
-}
+                }
+            }) =>
+        IsAdded = true;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs b/ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs
index 615d22278..5b4601f3c 100644
--- a/ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs
+++ b/ErsatzTV.Core.Tests/Fakes/FakeTelevisionRepository.cs
@@ -1,102 +1,97 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Tests.Fakes
+namespace ErsatzTV.Core.Tests.Fakes;
+
+public class FakeTelevisionRepository : ITelevisionRepository
 {
-    public class FakeTelevisionRepository : ITelevisionRepository
-    {
-        public Task<bool> AllShowsExist(List<int> showIds) => throw new NotSupportedException();
-        public Task<bool> AllSeasonsExist(List<int> seasonIds) => throw new NotSupportedException();
+    public Task<bool> AllShowsExist(List<int> showIds) => throw new NotSupportedException();
+    public Task<bool> AllSeasonsExist(List<int> seasonIds) => throw new NotSupportedException();
 
-        public Task<bool> AllEpisodesExist(List<int> episodeIds) => throw new NotSupportedException();
+    public Task<bool> AllEpisodesExist(List<int> episodeIds) => throw new NotSupportedException();
 
-        public Task<List<Show>> GetAllShows() => throw new NotSupportedException();
+    public Task<List<Show>> GetAllShows() => throw new NotSupportedException();
 
-        public Task<Option<Show>> GetShow(int showId) => throw new NotSupportedException();
+    public Task<Option<Show>> GetShow(int showId) => throw new NotSupportedException();
 
-        public Task<List<ShowMetadata>> GetShowsForCards(List<int> ids) => throw new NotSupportedException();
-        public Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids) => throw new NotSupportedException();
+    public Task<List<ShowMetadata>> GetShowsForCards(List<int> ids) => throw new NotSupportedException();
+    public Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids) => throw new NotSupportedException();
 
-        public Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids) => throw new NotSupportedException();
+    public Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids) => throw new NotSupportedException();
 
-        public Task<List<Episode>> GetShowItems(int showId) => throw new NotSupportedException();
+    public Task<List<Episode>> GetShowItems(int showId) => throw new NotSupportedException();
 
-        public Task<List<Season>> GetAllSeasons() => throw new NotSupportedException();
+    public Task<List<Season>> GetAllSeasons() => throw new NotSupportedException();
 
-        public Task<Option<Season>> GetSeason(int seasonId) => throw new NotSupportedException();
+    public Task<Option<Season>> GetSeason(int seasonId) => throw new NotSupportedException();
 
-        public Task<int> GetSeasonCount(int showId) => throw new NotSupportedException();
+    public Task<int> GetSeasonCount(int showId) => throw new NotSupportedException();
 
-        public Task<List<Season>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize) =>
-            throw new NotSupportedException();
+    public Task<List<Season>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize) =>
+        throw new NotSupportedException();
 
-        public Task<List<Episode>> GetSeasonItems(int seasonId) => throw new NotSupportedException();
+    public Task<List<Episode>> GetSeasonItems(int seasonId) => throw new NotSupportedException();
 
-        public Task<int> GetEpisodeCount(int seasonId) => throw new NotSupportedException();
+    public Task<int> GetEpisodeCount(int seasonId) => throw new NotSupportedException();
 
-        public Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize) =>
-            throw new NotSupportedException();
+    public Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize) =>
+        throw new NotSupportedException();
 
-        public Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata) =>
-            throw new NotSupportedException();
+    public Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata) =>
+        throw new NotSupportedException();
 
-        public Task<Either<BaseError, MediaItemScanResult<Show>>>
-            AddShow(int libraryPathId, string showFolder, ShowMetadata metadata) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, MediaItemScanResult<Show>>>
+        AddShow(int libraryPathId, string showFolder, ShowMetadata metadata) =>
+        throw new NotSupportedException();
 
-        public Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber) =>
+        throw new NotSupportedException();
 
-        public Task<Either<BaseError, Episode>> GetOrAddEpisode(Season season, LibraryPath libraryPath, string path) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, Episode>> GetOrAddEpisode(Season season, LibraryPath libraryPath, string path) =>
+        throw new NotSupportedException();
 
-        public Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath) => throw new NotSupportedException();
+    public Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath) => throw new NotSupportedException();
 
-        public Task<Unit> DeleteByPath(LibraryPath libraryPath, string path) => throw new NotSupportedException();
+    public Task<Unit> DeleteByPath(LibraryPath libraryPath, string path) => throw new NotSupportedException();
 
-        public Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath) => throw new NotSupportedException();
+    public Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath) => throw new NotSupportedException();
 
-        public Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath) => throw new NotSupportedException();
+    public Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath) => throw new NotSupportedException();
 
-        public Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(
-            PlexLibrary library,
-            PlexShow item) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(
+        PlexLibrary library,
+        PlexShow item) =>
+        throw new NotSupportedException();
 
-        public Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item) =>
+        throw new NotSupportedException();
 
-        public Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item) =>
-            throw new NotSupportedException();
+    public Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item) =>
+        throw new NotSupportedException();
 
-        public Task<bool> AddGenre(ShowMetadata metadata, Genre genre) => throw new NotSupportedException();
-        public Task<bool> AddTag(ShowMetadata metadata, Tag tag) => throw new NotSupportedException();
+    public Task<bool> AddGenre(ShowMetadata metadata, Genre genre) => throw new NotSupportedException();
+    public Task<bool> AddTag(ShowMetadata metadata, Tag tag) => throw new NotSupportedException();
 
-        public Task<bool> AddStudio(ShowMetadata metadata, Studio studio) => throw new NotSupportedException();
-        public Task<bool> AddActor(ShowMetadata metadata, Actor actor) => throw new NotSupportedException();
+    public Task<bool> AddStudio(ShowMetadata metadata, Studio studio) => throw new NotSupportedException();
+    public Task<bool> AddActor(ShowMetadata metadata, Actor actor) => throw new NotSupportedException();
 
-        public Task<bool> AddActor(EpisodeMetadata metadata, Actor actor) => throw new NotSupportedException();
+    public Task<bool> AddActor(EpisodeMetadata metadata, Actor actor) => throw new NotSupportedException();
 
-        public Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys) =>
-            throw new NotSupportedException();
+    public Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys) =>
+        throw new NotSupportedException();
 
-        public Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys) =>
-            throw new NotSupportedException();
+    public Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys) =>
+        throw new NotSupportedException();
 
-        public Task<List<int>> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys) =>
-            throw new NotSupportedException();
+    public Task<List<int>> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys) =>
+        throw new NotSupportedException();
 
-        public Task<Unit> RemoveMetadata(Episode episode, EpisodeMetadata metadata) =>
-            throw new NotSupportedException();
+    public Task<Unit> RemoveMetadata(Episode episode, EpisodeMetadata metadata) =>
+        throw new NotSupportedException();
 
-        public Task<bool> AddDirector(EpisodeMetadata metadata, Director director) => throw new NotSupportedException();
+    public Task<bool> AddDirector(EpisodeMetadata metadata, Director director) => throw new NotSupportedException();
 
-        public Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer) => throw new NotSupportedException();
-        public Task<Unit> UpdatePath(int mediaFileId, string path) => throw new NotSupportedException();
-    }
-}
+    public Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer) => throw new NotSupportedException();
+    public Task<Unit> UpdatePath(int mediaFileId, string path) => throw new NotSupportedException();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/GlobalUsings.cs b/ErsatzTV.Core.Tests/GlobalUsings.cs
new file mode 100644
index 000000000..9d0867420
--- /dev/null
+++ b/ErsatzTV.Core.Tests/GlobalUsings.cs
@@ -0,0 +1,4 @@
+global using LanguageExt;
+global using static LanguageExt.Prelude;
+global using Unit = LanguageExt.Unit;
+global using Array = System.Array;
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Jellyfin/JellyfinPathReplacementServiceTests.cs b/ErsatzTV.Core.Tests/Jellyfin/JellyfinPathReplacementServiceTests.cs
index 067c3ac42..3e61e914e 100644
--- a/ErsatzTV.Core.Tests/Jellyfin/JellyfinPathReplacementServiceTests.cs
+++ b/ErsatzTV.Core.Tests/Jellyfin/JellyfinPathReplacementServiceTests.cs
@@ -1,211 +1,207 @@
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Core.Jellyfin;
 using FluentAssertions;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Jellyfin
+namespace ErsatzTV.Core.Tests.Jellyfin;
+
+[TestFixture]
+public class JellyfinPathReplacementServiceTests
 {
-    [TestFixture]
-    public class JellyfinPathReplacementServiceTests
+    [Test]
+    public async Task JellyfinWindows_To_EtvWindows()
     {
-        [Test]
-        public async Task JellyfinWindows_To_EtvWindows()
+        var replacements = new List<JellyfinPathReplacement>
         {
-            var replacements = new List<JellyfinPathReplacement>
+            new()
             {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"C:\Something\Some Shared Folder",
-                    LocalPath = @"C:\Something Else\Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
-                }
-            };
+                Id = 1,
+                JellyfinPath = @"C:\Something\Some Shared Folder",
+                LocalPath = @"C:\Something Else\Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+            }
+        };
 
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
 
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
 
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
 
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
 
-            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinWindows_To_EtvLinux()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"C:\Something\Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinWindows_To_EtvLinux_UncPath()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinWindows_To_EtvLinux_UncPathWithTrailingSlash()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder\",
-                    LocalPath = @"/mnt/something else/Some Shared Folder/",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinLinux_To_EtvWindows()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"/mnt/something/Some Shared Folder",
-                    LocalPath = @"C:\Something Else\Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
-
-            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task JellyfinLinux_To_EtvLinux()
-        {
-            var replacements = new List<JellyfinPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    JellyfinPath = @"/mnt/something/Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new JellyfinPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<JellyfinPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementJellyfinPath(
-                0,
-                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
+        result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
     }
-}
+
+    [Test]
+    public async Task JellyfinWindows_To_EtvLinux()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"C:\Something\Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task JellyfinWindows_To_EtvLinux_UncPath()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task JellyfinWindows_To_EtvLinux_UncPathWithTrailingSlash()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"\\192.168.1.100\Something\Some Shared Folder\",
+                LocalPath = @"/mnt/something else/Some Shared Folder/",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task JellyfinLinux_To_EtvWindows()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"/mnt/something/Some Shared Folder",
+                LocalPath = @"C:\Something Else\Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+        result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task JellyfinLinux_To_EtvLinux()
+    {
+        var replacements = new List<JellyfinPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                JellyfinPath = @"/mnt/something/Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                JellyfinMediaSource = new JellyfinMediaSource { OperatingSystem = "Linux" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetJellyfinPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new JellyfinPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<JellyfinPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementJellyfinPath(
+            0,
+            @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Jellyfin/JellyfinUrlTests.cs b/ErsatzTV.Core.Tests/Jellyfin/JellyfinUrlTests.cs
index 21c3b672b..0ab7047bb 100644
--- a/ErsatzTV.Core.Tests/Jellyfin/JellyfinUrlTests.cs
+++ b/ErsatzTV.Core.Tests/Jellyfin/JellyfinUrlTests.cs
@@ -1,121 +1,118 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Jellyfin;
 using FluentAssertions;
 using Flurl;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.Jellyfin
+namespace ErsatzTV.Core.Tests.Jellyfin;
+
+public class JellyfinUrlTests
 {
-    public class JellyfinUrlTests
+    [Test]
+    public void Should_Work_Without_Trailing_Slash()
     {
-        [Test]
-        public void Should_Work_Without_Trailing_Slash()
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server";
+        var mediaSource = new JellyfinMediaSource
         {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server";
-            var mediaSource = new JellyfinMediaSource
+            Connections = new List<JellyfinConnection>
             {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
+                new() { Address = address }
+            }
+        };
 
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
 
-            url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server/";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Port_Without_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server:1000";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Port_With_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server:1000/";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Path_Prefix_Without_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server/jellyfin";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
-        }
-
-        [Test]
-        public void Should_Work_With_Path_Prefix_With_Trailing_Slash()
-        {
-            var artwork = "jellyfin://Items/2/Images/3?tag=4";
-            var address = "https://some.jellyfin.server/jellyfin/";
-            var mediaSource = new JellyfinMediaSource
-            {
-                Connections = new List<JellyfinConnection>
-                {
-                    new() { Address = address }
-                }
-            };
-
-            Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
-
-            url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
-        }
+        url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
     }
-}
+
+    [Test]
+    public void Should_Work_With_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server/";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server/Items/2/Images/3?tag=4");
+    }
+
+    [Test]
+    public void Should_Work_With_Port_Without_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server:1000";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
+    }
+
+    [Test]
+    public void Should_Work_With_Port_With_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server:1000/";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server:1000/Items/2/Images/3?tag=4");
+    }
+
+    [Test]
+    public void Should_Work_With_Path_Prefix_Without_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server/jellyfin";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
+    }
+
+    [Test]
+    public void Should_Work_With_Path_Prefix_With_Trailing_Slash()
+    {
+        var artwork = "jellyfin://Items/2/Images/3?tag=4";
+        var address = "https://some.jellyfin.server/jellyfin/";
+        var mediaSource = new JellyfinMediaSource
+        {
+            Connections = new List<JellyfinConnection>
+            {
+                new() { Address = address }
+            }
+        };
+
+        Url url = JellyfinUrl.ForArtwork(Some(mediaSource), artwork);
+
+        url.ToString().Should().Be("https://some.jellyfin.server/jellyfin/Items/2/Images/3?tag=4");
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Metadata/FallbackMetadataProviderTests.cs b/ErsatzTV.Core.Tests/Metadata/FallbackMetadataProviderTests.cs
index ae4a0f621..ffbe73de7 100644
--- a/ErsatzTV.Core.Tests/Metadata/FallbackMetadataProviderTests.cs
+++ b/ErsatzTV.Core.Tests/Metadata/FallbackMetadataProviderTests.cs
@@ -1,122 +1,120 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
 using FluentAssertions;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Metadata
+namespace ErsatzTV.Core.Tests.Metadata;
+
+[TestFixture]
+public class FallbackMetadataProviderTests
 {
-    [TestFixture]
-    public class FallbackMetadataProviderTests
+    [SetUp]
+    public void SetUp() => _fallbackMetadataProvider = new FallbackMetadataProvider();
+
+    private FallbackMetadataProvider _fallbackMetadataProvider;
+
+    [Test]
+    [TestCase("Awesome Show - s01e02.mkv", 1, 2)]
+    [TestCase("Awesome Show - S01E02.mkv", 1, 2)]
+    [TestCase("Awesome Show - s1e2.mkv", 1, 2)]
+    [TestCase("Awesome Show - S1E2.mkv", 1, 2)]
+    [TestCase("Awesome Show - s01e02 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show - S01E02 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show - s1e2 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show - S1E2 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show (2021) - s01e02 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show (2021) - S01E02 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show (2021) - s1e2 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show (2021) - S1E2 - Episode Title.mkv", 1, 2)]
+    [TestCase("Awesome Show - s01e02 - Episode Title-720p.mkv", 1, 2)]
+    [TestCase("Awesome Show - S01E02 - Episode Title-720p.mkv", 1, 2)]
+    [TestCase("Awesome Show - s1e2 - Episode Title-720p.mkv", 1, 2)]
+    [TestCase("Awesome Show - S1E2 - Episode Title-720p.mkv", 1, 2)]
+    [TestCase(
+        "Awesome Show (2021) - S01E02 - Description; More Description (1080p QUALITY codec GROUP).mkv",
+        1,
+        2)]
+    [TestCase(
+        "Awesome.Show.S01E02.Description.more.Description.QUAlity.codec.CODEC-GROUP.mkv",
+        1,
+        2)]
+    public void GetFallbackMetadata_ShouldHandleVariousFormats(string path, int season, int episode)
     {
-        [SetUp]
-        public void SetUp() => _fallbackMetadataProvider = new FallbackMetadataProvider();
-
-        private FallbackMetadataProvider _fallbackMetadataProvider;
-
-        [Test]
-        [TestCase("Awesome Show - s01e02.mkv", 1, 2)]
-        [TestCase("Awesome Show - S01E02.mkv", 1, 2)]
-        [TestCase("Awesome Show - s1e2.mkv", 1, 2)]
-        [TestCase("Awesome Show - S1E2.mkv", 1, 2)]
-        [TestCase("Awesome Show - s01e02 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show - S01E02 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show - s1e2 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show - S1E2 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show (2021) - s01e02 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show (2021) - S01E02 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show (2021) - s1e2 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show (2021) - S1E2 - Episode Title.mkv", 1, 2)]
-        [TestCase("Awesome Show - s01e02 - Episode Title-720p.mkv", 1, 2)]
-        [TestCase("Awesome Show - S01E02 - Episode Title-720p.mkv", 1, 2)]
-        [TestCase("Awesome Show - s1e2 - Episode Title-720p.mkv", 1, 2)]
-        [TestCase("Awesome Show - S1E2 - Episode Title-720p.mkv", 1, 2)]
-        [TestCase(
-            "Awesome Show (2021) - S01E02 - Description; More Description (1080p QUALITY codec GROUP).mkv",
-            1,
-            2)]
-        [TestCase(
-            "Awesome.Show.S01E02.Description.more.Description.QUAlity.codec.CODEC-GROUP.mkv",
-            1,
-            2)]
-        public void GetFallbackMetadata_ShouldHandleVariousFormats(string path, int season, int episode)
-        {
-            List<EpisodeMetadata> metadata = _fallbackMetadataProvider.GetFallbackMetadata(
-                new Episode
+        List<EpisodeMetadata> metadata = _fallbackMetadataProvider.GetFallbackMetadata(
+            new Episode
+            {
+                LibraryPath = new LibraryPath(),
+                MediaVersions = new List<MediaVersion>
                 {
-                    LibraryPath = new LibraryPath(),
-                    MediaVersions = new List<MediaVersion>
+                    new()
                     {
-                        new()
+                        MediaFiles = new List<MediaFile>
                         {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            }
+                            new() { Path = path }
                         }
                     }
-                });
+                }
+            });
 
-            metadata.Count.Should().Be(1);
-            // TODO: how can we test season number? do we need to?
-            // metadata.Season.Should().Be(season);
-            metadata.Head().EpisodeNumber.Should().Be(episode);
-        }
-
-        [Test]
-        [TestCase("Awesome Show - s01e02-s01e03.mkv", 1, 2, 3)]
-        [TestCase("Awesome Show - s01e02-whatever-s01e03-whatever2.mkv", 1, 2, 3)]
-        [TestCase("Awesome Show - s01e02e03.mkv", 1, 2, 3)]
-        [TestCase("Awesome Show - s01e02-03.mkv", 1, 2, 3)]
-        public void GetFallbackMetadata_Should_Handle_Two_Episode_Formats(
-            string path,
-            int season,
-            int episode1,
-            int episode2)
-        {
-            List<EpisodeMetadata> metadata = _fallbackMetadataProvider.GetFallbackMetadata(
-                new Episode
-                {
-                    LibraryPath = new LibraryPath(),
-                    MediaVersions = new List<MediaVersion>
-                    {
-                        new()
-                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            }
-                        }
-                    }
-                });
-
-            metadata.Count.Should().Be(2);
-            metadata.Map(m => m.EpisodeNumber).Should().BeEquivalentTo(new[] { episode1, episode2 });
-        }
-
-        [Test]
-        [TestCase("Something (2021).mkv", "Something")]
-        [TestCase("Something Else (2021).mkv", "Something Else")]
-        public void GetFallbackMetadata_Should_Set_Proper_Movie_Title(string path, string expectedTitle)
-        {
-            MovieMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadata(
-                new Movie
-                {
-                    LibraryPath = new LibraryPath(),
-                    MediaVersions = new List<MediaVersion>
-                    {
-                        new()
-                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            }
-                        }
-                    }
-                });
-
-            metadata.Should().NotBeNull();
-            metadata.Title.Should().Be(expectedTitle);
-        }
+        metadata.Count.Should().Be(1);
+        // TODO: how can we test season number? do we need to?
+        // metadata.Season.Should().Be(season);
+        metadata.Head().EpisodeNumber.Should().Be(episode);
     }
-}
+
+    [Test]
+    [TestCase("Awesome Show - s01e02-s01e03.mkv", 1, 2, 3)]
+    [TestCase("Awesome Show - s01e02-whatever-s01e03-whatever2.mkv", 1, 2, 3)]
+    [TestCase("Awesome Show - s01e02e03.mkv", 1, 2, 3)]
+    [TestCase("Awesome Show - s01e02-03.mkv", 1, 2, 3)]
+    public void GetFallbackMetadata_Should_Handle_Two_Episode_Formats(
+        string path,
+        int season,
+        int episode1,
+        int episode2)
+    {
+        List<EpisodeMetadata> metadata = _fallbackMetadataProvider.GetFallbackMetadata(
+            new Episode
+            {
+                LibraryPath = new LibraryPath(),
+                MediaVersions = new List<MediaVersion>
+                {
+                    new()
+                    {
+                        MediaFiles = new List<MediaFile>
+                        {
+                            new() { Path = path }
+                        }
+                    }
+                }
+            });
+
+        metadata.Count.Should().Be(2);
+        metadata.Map(m => m.EpisodeNumber).Should().BeEquivalentTo(new[] { episode1, episode2 });
+    }
+
+    [Test]
+    [TestCase("Something (2021).mkv", "Something")]
+    [TestCase("Something Else (2021).mkv", "Something Else")]
+    public void GetFallbackMetadata_Should_Set_Proper_Movie_Title(string path, string expectedTitle)
+    {
+        MovieMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadata(
+            new Movie
+            {
+                LibraryPath = new LibraryPath(),
+                MediaVersions = new List<MediaVersion>
+                {
+                    new()
+                    {
+                        MediaFiles = new List<MediaFile>
+                        {
+                            new() { Path = path }
+                        }
+                    }
+                }
+            });
+
+        metadata.Should().NotBeNull();
+        metadata.Title.Should().Be(expectedTitle);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Metadata/LocalStatisticsProviderTests.cs b/ErsatzTV.Core.Tests/Metadata/LocalStatisticsProviderTests.cs
index b749d837d..5c24cd547 100644
--- a/ErsatzTV.Core.Tests/Metadata/LocalStatisticsProviderTests.cs
+++ b/ErsatzTV.Core.Tests/Metadata/LocalStatisticsProviderTests.cs
@@ -1,6 +1,4 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
@@ -9,29 +7,28 @@ using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Metadata
+namespace ErsatzTV.Core.Tests.Metadata;
+
+[TestFixture]
+public class LocalStatisticsProviderTests
 {
-    [TestFixture]
-    public class LocalStatisticsProviderTests
+    [Test]
+    // this needs to be a culture where '.' is a group separator
+    [SetCulture("it-IT")] 
+    public void Test()
     {
-        [Test]
-        // this needs to be a culture where '.' is a group separator
-        [SetCulture("it-IT")] 
-        public void Test()
-        {
-            var provider = new LocalStatisticsProvider(
-                new Mock<IMetadataRepository>().Object,
-                new Mock<ILocalFileSystem>().Object,
-                new Mock<ILogger<LocalStatisticsProvider>>().Object);
+        var provider = new LocalStatisticsProvider(
+            new Mock<IMetadataRepository>().Object,
+            new Mock<ILocalFileSystem>().Object,
+            new Mock<ILogger<LocalStatisticsProvider>>().Object);
 
-            var input = new LocalStatisticsProvider.FFprobe(
-                new LocalStatisticsProvider.FFprobeFormat("123.45", null),
-                new List<LocalStatisticsProvider.FFprobeStream>(),
-                new List<LocalStatisticsProvider.FFprobeChapter>());
+        var input = new LocalStatisticsProvider.FFprobe(
+            new LocalStatisticsProvider.FFprobeFormat("123.45", null),
+            new List<LocalStatisticsProvider.FFprobeStream>(),
+            new List<LocalStatisticsProvider.FFprobeChapter>());
 
-            MediaVersion result = provider.ProjectToMediaVersion("test", input);
+        MediaVersion result = provider.ProjectToMediaVersion("test", input);
 
-            result.Duration.Should().Be(TimeSpan.FromSeconds(123.45));
-        }
+        result.Duration.Should().Be(TimeSpan.FromSeconds(123.45));
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs b/ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs
index d6276f02a..6ab74a585 100644
--- a/ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs
+++ b/ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs
@@ -1,11 +1,5 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
@@ -14,608 +8,604 @@ using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Metadata;
 using ErsatzTV.Core.Tests.Fakes;
 using FluentAssertions;
-using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Tests.Metadata
+namespace ErsatzTV.Core.Tests.Metadata;
+
+[TestFixture]
+public class MovieFolderScannerTests
 {
+    private static readonly string BadFakeRoot = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+        ? @"C:\Movies-That-Dont-Exist"
+        : @"/movies-that-dont-exist";
+
+    private static readonly string FakeRoot = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+        ? @"C:\Movies"
+        : "/movies";
+
+    private static readonly string FFprobePath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+        ? @"C:\bin\ffprobe.exe"
+        : "/bin/ffprobe";
+
     [TestFixture]
-    public class MovieFolderScannerTests
+    public class ScanFolder
     {
-        private static readonly string BadFakeRoot = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-            ? @"C:\Movies-That-Dont-Exist"
-            : @"/movies-that-dont-exist";
-
-        private static readonly string FakeRoot = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-            ? @"C:\Movies"
-            : "/movies";
-
-        private static readonly string FFprobePath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-            ? @"C:\bin\ffprobe.exe"
-            : "/bin/ffprobe";
-
-        [TestFixture]
-        public class ScanFolder
+        [SetUp]
+        public void SetUp()
         {
-            [SetUp]
-            public void SetUp()
-            {
-                _movieRepository = new Mock<IMovieRepository>();
-                _movieRepository.Setup(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()))
-                    .Returns(
-                        (LibraryPath _, string path) =>
-                            Right<BaseError, MediaItemScanResult<Movie>>(new FakeMovieWithPath(path)).AsTask());
-                _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
-                    .Returns(new List<string>().AsEnumerable().AsTask());
-
-                _mediaItemRepository = new Mock<IMediaItemRepository>();
-                _mediaItemRepository.Setup(x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()))
-                    .Returns(new List<int>().AsTask());
-
-                _localStatisticsProvider = new Mock<ILocalStatisticsProvider>();
-                _localMetadataProvider = new Mock<ILocalMetadataProvider>();
-
-                _localStatisticsProvider.Setup(x => x.RefreshStatistics(It.IsAny<string>(), It.IsAny<MediaItem>()))
-                    .Returns<string, MediaItem>((_, _) => Right<BaseError, bool>(true).AsTask());
-
-                // fallback metadata adds metadata to a movie, so we need to replicate that here
-                _localMetadataProvider.Setup(x => x.RefreshFallbackMetadata(It.IsAny<Movie>()))
-                    .Returns(
-                        (MediaItem mediaItem) =>
-                        {
-                            ((Movie) mediaItem).MovieMetadata = new List<MovieMetadata> { new() };
-                            return Task.FromResult(true);
-                        });
-
-                _imageCache = new Mock<IImageCache>();
-            }
-
-            private Mock<IMovieRepository> _movieRepository;
-            private Mock<IMediaItemRepository> _mediaItemRepository;
-            private Mock<ILocalStatisticsProvider> _localStatisticsProvider;
-            private Mock<ILocalMetadataProvider> _localMetadataProvider;
-            private Mock<IImageCache> _imageCache;
-
-            [Test]
-            public async Task NewMovie_Statistics_And_FallbackMetadata(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task NewMovie_Statistics_And_SidecarMetadata_MovieNameNfo(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                string metadataPath = Path.ChangeExtension(moviePath, "nfo");
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
-                    new FakeFileEntry(metadataPath)
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshSidecarMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath),
-                        metadataPath),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task NewMovie_Statistics_And_SidecarMetadata_MovieNfo(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                string metadataPath = Path.Combine(Path.GetDirectoryName(moviePath) ?? string.Empty, "movie.nfo");
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
-                    new FakeFileEntry(metadataPath)
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshSidecarMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath),
-                        metadataPath),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task NewMovie_Statistics_And_FallbackMetadata_And_Poster(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension,
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ImageFileExtensions))]
-                string imageExtension)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                string posterPath = Path.Combine(
-                    Path.GetDirectoryName(moviePath) ?? string.Empty,
-                    $"poster.{imageExtension}");
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
-                    new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _imageCache.Verify(
-                    x => x.CopyArtworkToCache(posterPath, ArtworkKind.Poster),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task NewMovie_Statistics_And_FallbackMetadata_And_FolderPoster(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension,
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ImageFileExtensions))]
-                string imageExtension)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                string posterPath = Path.Combine(
-                    Path.GetDirectoryName(moviePath) ?? string.Empty,
-                    $"folder.{imageExtension}");
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
-                    new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _imageCache.Verify(
-                    x => x.CopyArtworkToCache(posterPath, ArtworkKind.Poster),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task NewMovie_Statistics_And_FallbackMetadata_And_MovieNamePoster(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension,
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ImageFileExtensions))]
-                string imageExtension)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                string posterPath = Path.Combine(
-                    Path.GetDirectoryName(moviePath) ?? string.Empty,
-                    $"Movie (2020)-poster.{imageExtension}");
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
-                    new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _imageCache.Verify(
-                    x => x.CopyArtworkToCache(posterPath, ArtworkKind.Poster),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task Should_Ignore_Extra_Files(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension,
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ExtraFiles))]
-                string extraFile)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
-                    new FakeFileEntry(
-                        Path.Combine(
-                            Path.GetDirectoryName(moviePath) ?? string.Empty,
-                            $"Movie (2020)-{extraFile}{videoExtension}"))
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-            }
-            
-            [Test]
-            public async Task Should_Ignore_Dot_Underscore_Files(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
-                    new FakeFileEntry(
-                        Path.Combine(
-                            Path.GetDirectoryName(moviePath) ?? string.Empty,
-                            $"._Movie (2020){videoExtension}"))
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task Should_Ignore_Extra_Folders(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension,
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ExtraDirectories))]
-                string extraFolder)
-            {
-                string moviePath = Path.Combine(
-                    FakeRoot,
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
-                    new FakeFileEntry(
-                        Path.Combine(
-                            Path.GetDirectoryName(moviePath) ?? string.Empty,
-                            Path.Combine(extraFolder, $"Movie (2020){videoExtension}")))
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task Should_Work_With_Nested_Folders(
-                [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
-                string videoExtension)
-            {
-                string moviePath = Path.Combine(
-                    Path.Combine(FakeRoot, "L-P"),
-                    Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
-                _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
-
-                _localStatisticsProvider.Verify(
-                    x => x.RefreshStatistics(
-                        FFprobePath,
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-
-                _localMetadataProvider.Verify(
-                    x => x.RefreshFallbackMetadata(
-                        It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
-                    Times.Once);
-            }
-
-            [Test]
-            public async Task RenamedMovie_Should_Delete_Old_Movie()
-            {
-                // TODO: handle this case more elegantly
-                // ideally, detect that the movie was renamed and still delete the old one (or update the path?)
-
-                string movieFolder = Path.Combine(FakeRoot, "Movie (2020)");
-                string oldMoviePath = Path.Combine(movieFolder, "Movie (2020).avi");
-
-                _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
-                    .Returns(new List<string> { oldMoviePath }.AsEnumerable().AsTask());
-
-                string moviePath = Path.Combine(movieFolder, "Movie (2020).mkv");
-
-                MovieFolderScanner service = GetService(
-                    new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _mediaItemRepository.Verify(
-                    x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()),
-                    Times.Once);
-                _mediaItemRepository.Verify(x => x.FlagFileNotFound(libraryPath, oldMoviePath), Times.Once);
-            }
-
-            [Test]
-            public async Task DeletedMovieAndFolder_Should_Flag_File_Not_Found()
-            {
-                string movieFolder = Path.Combine(FakeRoot, "Movie (2020)");
-                string oldMoviePath = Path.Combine(movieFolder, "Movie (2020).avi");
-
-                _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
-                    .Returns(new List<string> { oldMoviePath }.AsEnumerable().AsTask());
-
-                MovieFolderScanner service = GetService(
-                    new FakeFolderEntry(FakeRoot)
-                );
-                var libraryPath = new LibraryPath
-                    { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
-
-                Either<BaseError, Unit> result = await service.ScanFolder(
-                    libraryPath,
-                    FFprobePath,
-                    0,
-                    1);
-
-                result.IsRight.Should().BeTrue();
-
-                _mediaItemRepository.Verify(
-                    x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()),
-                    Times.Once);
-                _mediaItemRepository.Verify(x => x.FlagFileNotFound(libraryPath, oldMoviePath), Times.Once);
-            }
-
-            private MovieFolderScanner GetService(params FakeFileEntry[] files) =>
-                new(
-                    new FakeLocalFileSystem(new List<FakeFileEntry>(files)),
-                    _movieRepository.Object,
-                    _localStatisticsProvider.Object,
-                    _localMetadataProvider.Object,
-                    new Mock<IMetadataRepository>().Object,
-                    _imageCache.Object,
-                    new Mock<ISearchIndex>().Object,
-                    new Mock<ISearchRepository>().Object,
-                    new Mock<ILibraryRepository>().Object,
-                    _mediaItemRepository.Object,
-                    new Mock<IMediator>().Object,
-                    null,
-                    new Mock<ITempFilePool>().Object,
-                    new Mock<ILogger<MovieFolderScanner>>().Object
-                );
-            
-            private MovieFolderScanner GetService(params FakeFolderEntry[] folders) =>
-                new(
-                    new FakeLocalFileSystem(new List<FakeFileEntry>(), new List<FakeFolderEntry>(folders)),
-                    _movieRepository.Object,
-                    _localStatisticsProvider.Object,
-                    _localMetadataProvider.Object,
-                    new Mock<IMetadataRepository>().Object,
-                    _imageCache.Object,
-                    new Mock<ISearchIndex>().Object,
-                    new Mock<ISearchRepository>().Object,
-                    new Mock<ILibraryRepository>().Object,
-                    _mediaItemRepository.Object,
-                    new Mock<IMediator>().Object,
-                    null,
-                    new Mock<ITempFilePool>().Object,
-                    new Mock<ILogger<MovieFolderScanner>>().Object
-                );
+            _movieRepository = new Mock<IMovieRepository>();
+            _movieRepository.Setup(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()))
+                .Returns(
+                    (LibraryPath _, string path) =>
+                        Right<BaseError, MediaItemScanResult<Movie>>(new FakeMovieWithPath(path)).AsTask());
+            _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
+                .Returns(new List<string>().AsEnumerable().AsTask());
+
+            _mediaItemRepository = new Mock<IMediaItemRepository>();
+            _mediaItemRepository.Setup(x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()))
+                .Returns(new List<int>().AsTask());
+
+            _localStatisticsProvider = new Mock<ILocalStatisticsProvider>();
+            _localMetadataProvider = new Mock<ILocalMetadataProvider>();
+
+            _localStatisticsProvider.Setup(x => x.RefreshStatistics(It.IsAny<string>(), It.IsAny<MediaItem>()))
+                .Returns<string, MediaItem>((_, _) => Right<BaseError, bool>(true).AsTask());
+
+            // fallback metadata adds metadata to a movie, so we need to replicate that here
+            _localMetadataProvider.Setup(x => x.RefreshFallbackMetadata(It.IsAny<Movie>()))
+                .Returns(
+                    (MediaItem mediaItem) =>
+                    {
+                        ((Movie) mediaItem).MovieMetadata = new List<MovieMetadata> { new() };
+                        return Task.FromResult(true);
+                    });
+
+            _imageCache = new Mock<IImageCache>();
         }
+
+        private Mock<IMovieRepository> _movieRepository;
+        private Mock<IMediaItemRepository> _mediaItemRepository;
+        private Mock<ILocalStatisticsProvider> _localStatisticsProvider;
+        private Mock<ILocalMetadataProvider> _localMetadataProvider;
+        private Mock<IImageCache> _imageCache;
+
+        [Test]
+        public async Task NewMovie_Statistics_And_FallbackMetadata(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshFallbackMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task NewMovie_Statistics_And_SidecarMetadata_MovieNameNfo(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            string metadataPath = Path.ChangeExtension(moviePath, "nfo");
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                new FakeFileEntry(metadataPath)
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshSidecarMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath),
+                    metadataPath),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task NewMovie_Statistics_And_SidecarMetadata_MovieNfo(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            string metadataPath = Path.Combine(Path.GetDirectoryName(moviePath) ?? string.Empty, "movie.nfo");
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                new FakeFileEntry(metadataPath)
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshSidecarMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath),
+                    metadataPath),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task NewMovie_Statistics_And_FallbackMetadata_And_Poster(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension,
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ImageFileExtensions))]
+            string imageExtension)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            string posterPath = Path.Combine(
+                Path.GetDirectoryName(moviePath) ?? string.Empty,
+                $"poster.{imageExtension}");
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshFallbackMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _imageCache.Verify(
+                x => x.CopyArtworkToCache(posterPath, ArtworkKind.Poster),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task NewMovie_Statistics_And_FallbackMetadata_And_FolderPoster(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension,
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ImageFileExtensions))]
+            string imageExtension)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            string posterPath = Path.Combine(
+                Path.GetDirectoryName(moviePath) ?? string.Empty,
+                $"folder.{imageExtension}");
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshFallbackMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _imageCache.Verify(
+                x => x.CopyArtworkToCache(posterPath, ArtworkKind.Poster),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task NewMovie_Statistics_And_FallbackMetadata_And_MovieNamePoster(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension,
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ImageFileExtensions))]
+            string imageExtension)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            string posterPath = Path.Combine(
+                Path.GetDirectoryName(moviePath) ?? string.Empty,
+                $"Movie (2020)-poster.{imageExtension}");
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                new FakeFileEntry(posterPath) { LastWriteTime = DateTime.Now }
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshFallbackMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _imageCache.Verify(
+                x => x.CopyArtworkToCache(posterPath, ArtworkKind.Poster),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task Should_Ignore_Extra_Files(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension,
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ExtraFiles))]
+            string extraFile)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                new FakeFileEntry(
+                    Path.Combine(
+                        Path.GetDirectoryName(moviePath) ?? string.Empty,
+                        $"Movie (2020)-{extraFile}{videoExtension}"))
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshFallbackMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+        }
+            
+        [Test]
+        public async Task Should_Ignore_Dot_Underscore_Files(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                new FakeFileEntry(
+                    Path.Combine(
+                        Path.GetDirectoryName(moviePath) ?? string.Empty,
+                        $"._Movie (2020){videoExtension}"))
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshFallbackMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task Should_Ignore_Extra_Folders(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension,
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.ExtraDirectories))]
+            string extraFolder)
+        {
+            string moviePath = Path.Combine(
+                FakeRoot,
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now },
+                new FakeFileEntry(
+                    Path.Combine(
+                        Path.GetDirectoryName(moviePath) ?? string.Empty,
+                        Path.Combine(extraFolder, $"Movie (2020){videoExtension}")))
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshFallbackMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task Should_Work_With_Nested_Folders(
+            [ValueSource(typeof(LocalFolderScanner), nameof(LocalFolderScanner.VideoFileExtensions))]
+            string videoExtension)
+        {
+            string moviePath = Path.Combine(
+                Path.Combine(FakeRoot, "L-P"),
+                Path.Combine("Movie (2020)", $"Movie (2020){videoExtension}"));
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _movieRepository.Verify(x => x.GetOrAdd(It.IsAny<LibraryPath>(), It.IsAny<string>()), Times.Once);
+            _movieRepository.Verify(x => x.GetOrAdd(libraryPath, moviePath), Times.Once);
+
+            _localStatisticsProvider.Verify(
+                x => x.RefreshStatistics(
+                    FFprobePath,
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+
+            _localMetadataProvider.Verify(
+                x => x.RefreshFallbackMetadata(
+                    It.Is<Movie>(i => i.MediaVersions.Head().MediaFiles.Head().Path == moviePath)),
+                Times.Once);
+        }
+
+        [Test]
+        public async Task RenamedMovie_Should_Delete_Old_Movie()
+        {
+            // TODO: handle this case more elegantly
+            // ideally, detect that the movie was renamed and still delete the old one (or update the path?)
+
+            string movieFolder = Path.Combine(FakeRoot, "Movie (2020)");
+            string oldMoviePath = Path.Combine(movieFolder, "Movie (2020).avi");
+
+            _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
+                .Returns(new List<string> { oldMoviePath }.AsEnumerable().AsTask());
+
+            string moviePath = Path.Combine(movieFolder, "Movie (2020).mkv");
+
+            MovieFolderScanner service = GetService(
+                new FakeFileEntry(moviePath) { LastWriteTime = DateTime.Now }
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _mediaItemRepository.Verify(
+                x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()),
+                Times.Once);
+            _mediaItemRepository.Verify(x => x.FlagFileNotFound(libraryPath, oldMoviePath), Times.Once);
+        }
+
+        [Test]
+        public async Task DeletedMovieAndFolder_Should_Flag_File_Not_Found()
+        {
+            string movieFolder = Path.Combine(FakeRoot, "Movie (2020)");
+            string oldMoviePath = Path.Combine(movieFolder, "Movie (2020).avi");
+
+            _movieRepository.Setup(x => x.FindMoviePaths(It.IsAny<LibraryPath>()))
+                .Returns(new List<string> { oldMoviePath }.AsEnumerable().AsTask());
+
+            MovieFolderScanner service = GetService(
+                new FakeFolderEntry(FakeRoot)
+            );
+            var libraryPath = new LibraryPath
+                { Id = 1, Path = FakeRoot, LibraryFolders = new List<LibraryFolder>() };
+
+            Either<BaseError, Unit> result = await service.ScanFolder(
+                libraryPath,
+                FFprobePath,
+                0,
+                1);
+
+            result.IsRight.Should().BeTrue();
+
+            _mediaItemRepository.Verify(
+                x => x.FlagFileNotFound(It.IsAny<LibraryPath>(), It.IsAny<string>()),
+                Times.Once);
+            _mediaItemRepository.Verify(x => x.FlagFileNotFound(libraryPath, oldMoviePath), Times.Once);
+        }
+
+        private MovieFolderScanner GetService(params FakeFileEntry[] files) =>
+            new(
+                new FakeLocalFileSystem(new List<FakeFileEntry>(files)),
+                _movieRepository.Object,
+                _localStatisticsProvider.Object,
+                _localMetadataProvider.Object,
+                new Mock<IMetadataRepository>().Object,
+                _imageCache.Object,
+                new Mock<ISearchIndex>().Object,
+                new Mock<ISearchRepository>().Object,
+                new Mock<ILibraryRepository>().Object,
+                _mediaItemRepository.Object,
+                new Mock<IMediator>().Object,
+                null,
+                new Mock<ITempFilePool>().Object,
+                new Mock<ILogger<MovieFolderScanner>>().Object
+            );
+            
+        private MovieFolderScanner GetService(params FakeFolderEntry[] folders) =>
+            new(
+                new FakeLocalFileSystem(new List<FakeFileEntry>(), new List<FakeFolderEntry>(folders)),
+                _movieRepository.Object,
+                _localStatisticsProvider.Object,
+                _localMetadataProvider.Object,
+                new Mock<IMetadataRepository>().Object,
+                _imageCache.Object,
+                new Mock<ISearchIndex>().Object,
+                new Mock<ISearchRepository>().Object,
+                new Mock<ILibraryRepository>().Object,
+                _mediaItemRepository.Object,
+                new Mock<IMediator>().Object,
+                null,
+                new Mock<ITempFilePool>().Object,
+                new Mock<ILogger<MovieFolderScanner>>().Object
+            );
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Metadata/Nfo/EpisodeNfoReaderTests.cs b/ErsatzTV.Core.Tests/Metadata/Nfo/EpisodeNfoReaderTests.cs
index fdd2f4a74..d76ee29a2 100644
--- a/ErsatzTV.Core.Tests/Metadata/Nfo/EpisodeNfoReaderTests.cs
+++ b/ErsatzTV.Core.Tests/Metadata/Nfo/EpisodeNfoReaderTests.cs
@@ -1,40 +1,36 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.Metadata.Nfo;
 using FluentAssertions;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Metadata.Nfo
+namespace ErsatzTV.Core.Tests.Metadata.Nfo;
+
+[TestFixture]
+public class EpisodeNfoReaderTests
 {
-    [TestFixture]
-    public class EpisodeNfoReaderTests
+    [Test]
+    public async Task One()
     {
-        [Test]
-        public async Task One()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(1);
-        }
+        result.Count.Should().Be(1);
+    }
 
-        [Test]
-        public async Task Two()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Two()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <showtitle>show</showtitle>
@@ -49,61 +45,61 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
   <season>1</season>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(2);
-            result.All(nfo => nfo.ShowTitle == "show").Should().BeTrue();
-            result.All(nfo => nfo.Season == 1).Should().BeTrue();
-            result.Count(nfo => nfo.Title == "episode-one" && nfo.Episode == 1).Should().Be(1);
-            result.Count(nfo => nfo.Title == "episode-two" && nfo.Episode == 2).Should().Be(1);
-        }
+        result.Count.Should().Be(2);
+        result.All(nfo => nfo.ShowTitle == "show").Should().BeTrue();
+        result.All(nfo => nfo.Season == 1).Should().BeTrue();
+        result.Count(nfo => nfo.Title == "episode-one" && nfo.Episode == 1).Should().Be(1);
+        result.Count(nfo => nfo.Title == "episode-two" && nfo.Episode == 2).Should().Be(1);
+    }
 
-        [Test]
-        public async Task UniqueIds()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task UniqueIds()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <uniqueid default=""true"" type=""tvdb"">12345</uniqueid>
   <uniqueid default=""false"" type=""imdb"">tt54321</uniqueid>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(1);
-            result[0].UniqueIds.Count.Should().Be(2);
-            result[0].UniqueIds.Count(id => id.Default && id.Type == "tvdb" && id.Guid == "12345").Should().Be(1);
-            result[0].UniqueIds.Count(id => !id.Default && id.Type == "imdb" && id.Guid == "tt54321").Should().Be(1);
-        }
+        result.Count.Should().Be(1);
+        result[0].UniqueIds.Count.Should().Be(2);
+        result[0].UniqueIds.Count(id => id.Default && id.Type == "tvdb" && id.Guid == "12345").Should().Be(1);
+        result[0].UniqueIds.Count(id => !id.Default && id.Type == "imdb" && id.Guid == "tt54321").Should().Be(1);
+    }
 
-        [Test]
-        public async Task No_ContentRating()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task No_ContentRating()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <mpaa/>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(1);
-            result[0].ContentRating.Should().BeNullOrEmpty();
-        }
+        result.Count.Should().Be(1);
+        result[0].ContentRating.Should().BeNullOrEmpty();
+    }
 
-        [Test]
-        public async Task ContentRating()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task ContentRating()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <mpaa>US:Something</mpaa>
@@ -112,56 +108,56 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
   <mpaa>US:Something / US:SomethingElse</mpaa>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(2);
-            result.Count(nfo => nfo.ContentRating == "US:Something").Should().Be(1);
-            result.Count(nfo => nfo.ContentRating == "US:Something / US:SomethingElse").Should().Be(1);
-        }
+        result.Count.Should().Be(2);
+        result.Count(nfo => nfo.ContentRating == "US:Something").Should().Be(1);
+        result.Count(nfo => nfo.ContentRating == "US:Something / US:SomethingElse").Should().Be(1);
+    }
 
-        [Test]
-        public async Task No_Plot()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task No_Plot()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <plot/>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(1);
-            result[0].Plot.Should().BeNullOrEmpty();
-        }
+        result.Count.Should().Be(1);
+        result[0].Plot.Should().BeNullOrEmpty();
+    }
 
-        [Test]
-        public async Task Plot()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Plot()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <plot>Some Plot</plot>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(1);
-            result[0].Plot.Should().Be("Some Plot");
-        }
+        result.Count.Should().Be(1);
+        result[0].Plot.Should().Be("Some Plot");
+    }
 
-        [Test]
-        public async Task Actors()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Actors()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <actor>
@@ -176,23 +172,23 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
   </actor>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(1);
-            result[0].Actors.Count.Should().Be(2);
-            result[0].Actors.Count(a => a.Name == "Name 1" && a.Role == "Role 1" && a.Thumb == "Thumb 1")
-                .Should().Be(1);
-            result[0].Actors.Count(a => a.Name == "Name 2" && a.Role == "Role 2" && a.Thumb == "Thumb 2")
-                .Should().Be(1);
-        }
+        result.Count.Should().Be(1);
+        result[0].Actors.Count.Should().Be(2);
+        result[0].Actors.Count(a => a.Name == "Name 1" && a.Role == "Role 1" && a.Thumb == "Thumb 1")
+            .Should().Be(1);
+        result[0].Actors.Count(a => a.Name == "Name 2" && a.Role == "Role 2" && a.Thumb == "Thumb 2")
+            .Should().Be(1);
+    }
 
-        [Test]
-        public async Task Writers()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Writers()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <credits>Writer 1</credits>
@@ -202,21 +198,21 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
   <credits>Writer 3</credits>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(2);
-            result.Count(nfo => nfo.Writers.Count == 1 && nfo.Writers[0] == "Writer 1").Should().Be(1);
-            result.Count(nfo => nfo.Writers.Count == 2 && nfo.Writers[0] == "Writer 2" && nfo.Writers[1] == "Writer 3")
-                .Should().Be(1);
-        }
+        result.Count.Should().Be(2);
+        result.Count(nfo => nfo.Writers.Count == 1 && nfo.Writers[0] == "Writer 1").Should().Be(1);
+        result.Count(nfo => nfo.Writers.Count == 2 && nfo.Writers[0] == "Writer 2" && nfo.Writers[1] == "Writer 3")
+            .Should().Be(1);
+    }
 
-        [Test]
-        public async Task Directors()
-        {
-            var reader = new EpisodeNfoReader();
-            var stream = new MemoryStream(
-                Encoding.UTF8.GetBytes(
-                    @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
+    [Test]
+    public async Task Directors()
+    {
+        var reader = new EpisodeNfoReader();
+        var stream = new MemoryStream(
+            Encoding.UTF8.GetBytes(
+                @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
 <!--created on whatever - comment-->
 <episodedetails>
   <director>Director 1</director>
@@ -226,14 +222,13 @@ namespace ErsatzTV.Core.Tests.Metadata.Nfo
   <director>Director 3</director>
 </episodedetails>"));
 
-            List<TvShowEpisodeNfo> result = await reader.Read(stream);
+        List<TvShowEpisodeNfo> result = await reader.Read(stream);
 
-            result.Count.Should().Be(2);
-            result.Count(nfo => nfo.Directors.Count == 1 && nfo.Directors[0] == "Director 1").Should().Be(1);
-            result.Count(
-                    nfo => nfo.Directors.Count == 2 && nfo.Directors[0] == "Director 2" &&
-                           nfo.Directors[1] == "Director 3")
-                .Should().Be(1);
-        }
+        result.Count.Should().Be(2);
+        result.Count(nfo => nfo.Directors.Count == 1 && nfo.Directors[0] == "Director 1").Should().Be(1);
+        result.Count(
+                nfo => nfo.Directors.Count == 2 && nfo.Directors[0] == "Director 2" &&
+                       nfo.Directors[1] == "Director 3")
+            .Should().Be(1);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Plex/PlexPathReplacementServiceTests.cs b/ErsatzTV.Core.Tests/Plex/PlexPathReplacementServiceTests.cs
index e4cbd33af..582a4f8c4 100644
--- a/ErsatzTV.Core.Tests/Plex/PlexPathReplacementServiceTests.cs
+++ b/ErsatzTV.Core.Tests/Plex/PlexPathReplacementServiceTests.cs
@@ -1,211 +1,207 @@
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Core.Plex;
 using FluentAssertions;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Plex
+namespace ErsatzTV.Core.Tests.Plex;
+
+[TestFixture]
+public class PlexPathReplacementServiceTests
 {
-    [TestFixture]
-    public class PlexPathReplacementServiceTests
+    [Test]
+    public async Task PlexWindows_To_EtvWindows()
     {
-        [Test]
-        public async Task PlexWindows_To_EtvWindows()
+        var replacements = new List<PlexPathReplacement>
         {
-            var replacements = new List<PlexPathReplacement>
+            new()
             {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"C:\Something\Some Shared Folder",
-                    LocalPath = @"C:\Something Else\Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
-                }
-            };
+                Id = 1,
+                PlexPath = @"C:\Something\Some Shared Folder",
+                LocalPath = @"C:\Something Else\Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+            }
+        };
 
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
 
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
 
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
 
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
 
-            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexWindows_To_EtvLinux()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"C:\Something\Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexWindows_To_EtvLinux_UncPath()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"\\192.168.1.100\Something\Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexWindows_To_EtvLinux_UncPathWithTrailingSlash()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"\\192.168.1.100\Something\Some Shared Folder\",
-                    LocalPath = @"/mnt/something else/Some Shared Folder/",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexLinux_To_EtvWindows()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"/mnt/something/Some Shared Folder",
-                    LocalPath = @"C:\Something Else\Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
-
-            result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
-        }
-
-        [Test]
-        public async Task PlexLinux_To_EtvLinux()
-        {
-            var replacements = new List<PlexPathReplacement>
-            {
-                new()
-                {
-                    Id = 1,
-                    PlexPath = @"/mnt/something/Some Shared Folder",
-                    LocalPath = @"/mnt/something else/Some Shared Folder",
-                    PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
-                }
-            };
-
-            var repo = new Mock<IMediaSourceRepository>();
-            repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
-
-            var runtime = new Mock<IRuntimeInfo>();
-            runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
-
-            var service = new PlexPathReplacementService(
-                repo.Object,
-                runtime.Object,
-                new Mock<ILogger<PlexPathReplacementService>>().Object);
-
-            string result = await service.GetReplacementPlexPath(
-                0,
-                @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
-
-            result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
-        }
+        result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
     }
-}
+
+    [Test]
+    public async Task PlexWindows_To_EtvLinux()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"C:\Something\Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"C:\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task PlexWindows_To_EtvLinux_UncPath()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"\\192.168.1.100\Something\Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task PlexWindows_To_EtvLinux_UncPathWithTrailingSlash()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"\\192.168.1.100\Something\Some Shared Folder\",
+                LocalPath = @"/mnt/something else/Some Shared Folder/",
+                PlexMediaSource = new PlexMediaSource { Platform = "Windows" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"\\192.168.1.100\Something\Some Shared Folder\Some Movie\Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task PlexLinux_To_EtvWindows()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"/mnt/something/Some Shared Folder",
+                LocalPath = @"C:\Something Else\Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(true);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+        result.Should().Be(@"C:\Something Else\Some Shared Folder\Some Movie\Some Movie.mkv");
+    }
+
+    [Test]
+    public async Task PlexLinux_To_EtvLinux()
+    {
+        var replacements = new List<PlexPathReplacement>
+        {
+            new()
+            {
+                Id = 1,
+                PlexPath = @"/mnt/something/Some Shared Folder",
+                LocalPath = @"/mnt/something else/Some Shared Folder",
+                PlexMediaSource = new PlexMediaSource { Platform = "Linux" }
+            }
+        };
+
+        var repo = new Mock<IMediaSourceRepository>();
+        repo.Setup(x => x.GetPlexPathReplacementsByLibraryId(It.IsAny<int>())).Returns(replacements.AsTask());
+
+        var runtime = new Mock<IRuntimeInfo>();
+        runtime.Setup(x => x.IsOSPlatform(OSPlatform.Windows)).Returns(false);
+
+        var service = new PlexPathReplacementService(
+            repo.Object,
+            runtime.Object,
+            new Mock<ILogger<PlexPathReplacementService>>().Object);
+
+        string result = await service.GetReplacementPlexPath(
+            0,
+            @"/mnt/something/Some Shared Folder/Some Movie/Some Movie.mkv");
+
+        result.Should().Be(@"/mnt/something else/Some Shared Folder/Some Movie/Some Movie.mkv");
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/ChronologicalContentTests.cs b/ErsatzTV.Core.Tests/Scheduling/ChronologicalContentTests.cs
index d4f1eef18..387f24ab9 100644
--- a/ErsatzTV.Core.Tests/Scheduling/ChronologicalContentTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/ChronologicalContentTests.cs
@@ -1,92 +1,87 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class ChronologicalContentTests
 {
-    [TestFixture]
-    public class ChronologicalContentTests
+    [Test]
+    public void Episodes_Should_Sort_By_Aired()
     {
-        [Test]
-        public void Episodes_Should_Sort_By_Aired()
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
+
+        for (var i = 1; i <= 10; i++)
         {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
-
-            for (var i = 1; i <= 10; i++)
-            {
-                chronologicalContent.Current.IsSome.Should().BeTrue();
-                chronologicalContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                chronologicalContent.MoveNext();
-            }
+            chronologicalContent.Current.IsSome.Should().BeTrue();
+            chronologicalContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            chronologicalContent.MoveNext();
         }
-
-        [Test]
-        public void State_Index_Should_Increment()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
-
-            for (var i = 0; i < 10; i++)
-            {
-                chronologicalContent.State.Index.Should().Be(i % 10);
-                chronologicalContent.MoveNext();
-            }
-        }
-
-        [Test]
-        public void State_Should_Impact_Iterator_Start()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 5 };
-
-            var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
-
-            for (var i = 6; i <= 10; i++)
-            {
-                chronologicalContent.Current.IsSome.Should().BeTrue();
-                chronologicalContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                chronologicalContent.State.Index.Should().Be(i - 1);
-                chronologicalContent.MoveNext();
-            }
-        }
-
-        [Test]
-        [Timeout(1000)]
-        public void State_Should_Reset_When_Invalid()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 10 };
-
-            var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
-
-            chronologicalContent.State.Index.Should().Be(0);
-            chronologicalContent.State.Seed.Should().Be(0);
-        }
-
-        private static List<MediaItem> Episodes(int count) =>
-            Range(1, count).Map(
-                    i => (MediaItem) new Episode
-                    {
-                        Id = i,
-                        EpisodeMetadata = new List<EpisodeMetadata>
-                        {
-                            new()
-                            {
-                                ReleaseDate = new DateTime(2020, 1, i)
-                            }
-                        }
-                    })
-                .Reverse()
-                .ToList();
     }
-}
+
+    [Test]
+    public void State_Index_Should_Increment()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
+
+        for (var i = 0; i < 10; i++)
+        {
+            chronologicalContent.State.Index.Should().Be(i % 10);
+            chronologicalContent.MoveNext();
+        }
+    }
+
+    [Test]
+    public void State_Should_Impact_Iterator_Start()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 5 };
+
+        var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
+
+        for (var i = 6; i <= 10; i++)
+        {
+            chronologicalContent.Current.IsSome.Should().BeTrue();
+            chronologicalContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            chronologicalContent.State.Index.Should().Be(i - 1);
+            chronologicalContent.MoveNext();
+        }
+    }
+
+    [Test]
+    [Timeout(1000)]
+    public void State_Should_Reset_When_Invalid()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 10 };
+
+        var chronologicalContent = new ChronologicalMediaCollectionEnumerator(contents, state);
+
+        chronologicalContent.State.Index.Should().Be(0);
+        chronologicalContent.State.Seed.Should().Be(0);
+    }
+
+    private static List<MediaItem> Episodes(int count) =>
+        Range(1, count).Map(
+                i => (MediaItem) new Episode
+                {
+                    Id = i,
+                    EpisodeMetadata = new List<EpisodeMetadata>
+                    {
+                        new()
+                        {
+                            ReleaseDate = new DateTime(2020, 1, i)
+                        }
+                    }
+                })
+            .Reverse()
+            .ToList();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/CustomOrderContentTests.cs b/ErsatzTV.Core.Tests/Scheduling/CustomOrderContentTests.cs
index a03a1522f..27249f1ee 100644
--- a/ErsatzTV.Core.Tests/Scheduling/CustomOrderContentTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/CustomOrderContentTests.cs
@@ -1,100 +1,95 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+public class CustomOrderContentTests
 {
-    public class CustomOrderContentTests
+    [Test]
+    public void MediaItems_Should_Sort_By_CustomOrder()
     {
-        [Test]
-        public void MediaItems_Should_Sort_By_CustomOrder()
+        Collection collection = CreateCollection(10);
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
+
+        for (var i = 10; i >= 1; i--)
         {
-            Collection collection = CreateCollection(10);
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
-
-            for (var i = 10; i >= 1; i--)
-            {
-                customOrderContent.Current.IsSome.Should().BeTrue();
-                customOrderContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                customOrderContent.MoveNext();
-            }
+            customOrderContent.Current.IsSome.Should().BeTrue();
+            customOrderContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            customOrderContent.MoveNext();
         }
-
-        [Test]
-        public void State_Index_Should_Increment()
-        {
-            Collection collection = CreateCollection(10);
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
-
-            for (var i = 0; i < 10; i++)
-            {
-                customOrderContent.State.Index.Should().Be(i % 10);
-                customOrderContent.MoveNext();
-            }
-        }
-
-        [Test]
-        public void State_Should_Impact_Iterator_Start()
-        {
-            Collection collection = CreateCollection(10);
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 5 };
-
-            var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
-
-            for (var i = 5; i >= 1; i--)
-            {
-                customOrderContent.Current.IsSome.Should().BeTrue();
-                customOrderContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                customOrderContent.State.Index.Should().Be(5 - i + 5); // 5 through 10
-                customOrderContent.MoveNext();
-            }
-        }
-
-        private static Collection CreateCollection(int episodeCount)
-        {
-            var collection = new Collection { CollectionItems = new List<CollectionItem>() };
-
-            for (var i = 1; i <= episodeCount; i++)
-            {
-                collection.CollectionItems.Add(
-                    new CollectionItem
-                    {
-                        MediaItemId = i,
-                        // reverse order
-                        CustomIndex = episodeCount - i
-                    });
-            }
-
-            return collection;
-        }
-
-
-        private static List<MediaItem> Episodes(int count) =>
-            Range(1, count).Map(
-                    i => (MediaItem) new Episode
-                    {
-                        Id = i,
-                        EpisodeMetadata = new List<EpisodeMetadata>
-                        {
-                            new()
-                            {
-                                ReleaseDate = new DateTime(2020, 1, i)
-                            }
-                        }
-                    })
-                .Reverse()
-                .ToList();
     }
-}
+
+    [Test]
+    public void State_Index_Should_Increment()
+    {
+        Collection collection = CreateCollection(10);
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
+
+        for (var i = 0; i < 10; i++)
+        {
+            customOrderContent.State.Index.Should().Be(i % 10);
+            customOrderContent.MoveNext();
+        }
+    }
+
+    [Test]
+    public void State_Should_Impact_Iterator_Start()
+    {
+        Collection collection = CreateCollection(10);
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 5 };
+
+        var customOrderContent = new CustomOrderCollectionEnumerator(collection, contents, state);
+
+        for (var i = 5; i >= 1; i--)
+        {
+            customOrderContent.Current.IsSome.Should().BeTrue();
+            customOrderContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            customOrderContent.State.Index.Should().Be(5 - i + 5); // 5 through 10
+            customOrderContent.MoveNext();
+        }
+    }
+
+    private static Collection CreateCollection(int episodeCount)
+    {
+        var collection = new Collection { CollectionItems = new List<CollectionItem>() };
+
+        for (var i = 1; i <= episodeCount; i++)
+        {
+            collection.CollectionItems.Add(
+                new CollectionItem
+                {
+                    MediaItemId = i,
+                    // reverse order
+                    CustomIndex = episodeCount - i
+                });
+        }
+
+        return collection;
+    }
+
+
+    private static List<MediaItem> Episodes(int count) =>
+        Range(1, count).Map(
+                i => (MediaItem) new Episode
+                {
+                    Id = i,
+                    EpisodeMetadata = new List<EpisodeMetadata>
+                    {
+                        new()
+                        {
+                            ReleaseDate = new DateTime(2020, 1, i)
+                        }
+                    }
+                })
+            .Reverse()
+            .ToList();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/MultiPartEpisodeGrouperTests.cs b/ErsatzTV.Core.Tests/Scheduling/MultiPartEpisodeGrouperTests.cs
index 2119d8ec5..a1c9c132e 100644
--- a/ErsatzTV.Core.Tests/Scheduling/MultiPartEpisodeGrouperTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/MultiPartEpisodeGrouperTests.cs
@@ -1,337 +1,333 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+public class MultiPartEpisodeGrouperTests
 {
-    public class MultiPartEpisodeGrouperTests
+    [Test]
+    [TestCase("Episode 1", "Episode 2 (1)", "Episode 3 (2)", "Episode 4")]
+    [TestCase("Episode 1 - More", "Episode 2 (1) - Title", "Episode 3 (2) - After", "Episode 4 - Dash")]
+    [TestCase("Episode 1", "Episode 2 Part 1", "Episode 3 Part 2", "Episode 4")]
+    [TestCase("Episode 1", "Episode 2 (Part 1)", "Episode 3 (Part 2)", "Episode 4")]
+    public void NotGrouped_Grouped_NotGrouped(string one, string two, string three, string four)
     {
-        [Test]
-        [TestCase("Episode 1", "Episode 2 (1)", "Episode 3 (2)", "Episode 4")]
-        [TestCase("Episode 1 - More", "Episode 2 (1) - Title", "Episode 3 (2) - After", "Episode 4 - Dash")]
-        [TestCase("Episode 1", "Episode 2 Part 1", "Episode 3 Part 2", "Episode 4")]
-        [TestCase("Episode 1", "Episode 2 (Part 1)", "Episode 3 (Part 2)", "Episode 4")]
-        public void NotGrouped_Grouped_NotGrouped(string one, string two, string three, string four)
+        var mediaItems = new List<MediaItem>
         {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4)
-            };
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4)
+        };
 
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
 
-            result.Count.Should().Be(3);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 2 - Part 2", "Episode 3")]
-        [TestCase("Episode 1 Part 1", "Episode 2 (2) - More", "Episode 3 - After")]
-        [TestCase("Episode 1 Part 1", "Episode 2 (II)", "Episode 3")]
-        [TestCase("Episode 1 Part One", "Episode 2 (II)", "Episode 3")]
-        [TestCase("Episode 1 (1)", "Episode 2 (Part 2)", "Episode 3")]
-        public void MixedNaming_Group(string one, string two, string three)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(2);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (5)", "Episode 2 - (6)", "Episode 3")]
-        [TestCase("Episode 1 Part 5", "Episode 2 Part 6", "Episode 3 - After")]
-        [TestCase("Episode 1 Part (V)", "Episode 2 (VI)", "Episode 3")]
-        [TestCase("Episode 1 (Part 5)", "Episode 2 (Part 6)", "Episode 3")]
-        public void Only_Later_Parts(string one, string two, string three)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(2);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3")]
-        [TestCase("Episode 1 (1) - More", "Episode 2 (2) - Title", "Episode 3 - After")]
-        [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3")]
-        [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3")]
-        public void Grouped_NotGrouped(string one, string two, string three)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(2);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3", "Episode 4 (1)", "Episode 5 (2)")]
-        [TestCase(
-            "Episode 1 (1) - More",
-            "Episode 2 (2) - Title",
-            "Episode 3 - After",
-            "Episode 4 (1) - Dash",
-            "Episode 5 (2) - Again")]
-        [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3", "Episode 4 Part 1", "Episode 5 Part 2")]
-        [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3", "Episode 4 (Part 1)", "Episode 5 (Part 2)")]
-        public void Grouped_NotGrouped_Grouped(string one, string two, string three, string four, string five)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4),
-                NamedEpisode(five, 1, 1, 5)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-            ShouldHaveTwoItems(result, mediaItems[3], mediaItems[4]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3 (1)", "Episode 4 (2)")]
-        [TestCase("Episode 1 (1) - More", "Episode 2 (2) - Title", "Episode 3 (1) - After", "Episode 4 (2) - Dash")]
-        [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3 Part 1", "Episode 4 Part 2")]
-        [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3 (Part 1)", "Episode 4 (Part 2)")]
-        public void Grouped_Grouped(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(2);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
-            ShouldHaveTwoItems(result, mediaItems[2], mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1", "Episode 2 (2)", "Episode 3 (1)", "Episode 4 (2)")]
-        [TestCase("Episode 1 - More", "Episode 2 (2) - Title", "Episode 3 (1) - After", "Episode 4 (2) - Dash")]
-        [TestCase("Episode 1", "Episode 2 Part 2", "Episode 3 Part 1", "Episode 4 Part 2")]
-        [TestCase("Episode 1", "Episode 2 (Part 2)", "Episode 3 (Part 1)", "Episode 4 (Part 2)")]
-        public void Part2_Without_Part1(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveOneItem(result, mediaItems[1]);
-            ShouldHaveTwoItems(result, mediaItems[2], mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1", "Episode 2 (2)", "Episode 3 (3)", "Episode 4")]
-        [TestCase("Episode 1 - More", "Episode 2 (2) - Title", "Episode 3 (3) - After", "Episode 4 - Dash")]
-        [TestCase("Episode 1", "Episode 2 Part 2", "Episode 3 Part 3", "Episode 4")]
-        [TestCase("Episode 1", "Episode 2 (Part 2)", "Episode 3 (Part 3)", "Episode 4")]
-        public void Part2And3_Without_Part1(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 2),
-                NamedEpisode(three, 1, 1, 3),
-                NamedEpisode(four, 1, 1, 4)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 3 (3)", "Episode 4", "Episode 5")]
-        [TestCase("Episode 1 (1) - More", "Episode 3 (3) - Title", "Episode 4 - After", "Episode 5 - Dash")]
-        [TestCase("Episode 1 Part 1", "Episode 3 Part 3", "Episode 4", "Episode 5")]
-        [TestCase("Episode 1 (Part 1)", "Episode 3 (Part 3)", "Episode 4", "Episode 5")]
-        public void Skip_Part(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 3),
-                NamedEpisode(three, 1, 1, 4),
-                NamedEpisode(four, 1, 1, 5)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(4);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveOneItem(result, mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("Episode 1 (1)", "Episode 3 (1)", "Episode 4 (2)", "Episode 5")]
-        [TestCase("Episode 1 (1) - More", "Episode 3 (1) - Title", "Episode 4 (2) - After", "Episode 5 - Dash")]
-        [TestCase("Episode 1 Part 1", "Episode 3 Part 1", "Episode 4 Part 2", "Episode 5")]
-        [TestCase("Episode 1 (Part 1)", "Episode 3 (Part 1)", "Episode 4 (Part 2)", "Episode 5")]
-        public void Repeat_Part(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1),
-                NamedEpisode(two, 1, 1, 3),
-                NamedEpisode(three, 1, 1, 4),
-                NamedEpisode(four, 1, 1, 5)
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveOneItem(result, mediaItems[0]);
-            ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("S1 Episode 1 (1)", "S2 Episode 3 (1)", "S1 Episode 2 (2)", "S1 Episode 5")]
-        [TestCase(
-            "S1 Episode 1 (1) - More",
-            "S2 Episode 3 (1) - Title",
-            "S1 Episode 2 (2) - After",
-            "S1 Episode 5 - Dash")]
-        [TestCase("S1 Episode 1 Part 1", "S2 Episode 3 Part 1", "S1 Episode 2 Part 2", "S1 Episode 5")]
-        [TestCase("S1 Episode 1 (Part 1)", "S2 Episode 3 (Part 1)", "S1 Episode 2 (Part 2)", "S1 Episode 5")]
-        public void Mixed_Shows_Chronologically(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1, new DateTime(2020, 1, 1)),
-                NamedEpisode(two, 2, 1, 3, new DateTime(2020, 1, 2)),
-                NamedEpisode(three, 1, 1, 2, new DateTime(2020, 1, 3)),
-                NamedEpisode(four, 1, 1, 5, new DateTime(2020, 1, 4))
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
-
-            result.Count.Should().Be(3);
-            ShouldHaveTwoItems(result, mediaItems[0], mediaItems[2]);
-            ShouldHaveOneItem(result, mediaItems[1]);
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        [Test]
-        [TestCase("S1 Episode 1 (1)", "S2 Episode 3 (2)", "S1 Episode 2 (3)", "S1 Episode 5")]
-        [TestCase(
-            "S1 Episode 1 (1) - More",
-            "S2 Episode 3 (2) - Title",
-            "S1 Episode 2 (3) - After",
-            "S1 Episode 5 - Dash")]
-        [TestCase("S1 Episode 1 Part 1", "S2 Episode 3 Part 2", "S1 Episode 2 Part 3", "S1 Episode 5")]
-        [TestCase("S1 Episode 1 (Part 1)", "S2 Episode 3 (Part 2)", "S1 Episode 2 (Part 3)", "S1 Episode 5")]
-        public void Mixed_Shows_Chronologically_Crossover(string one, string two, string three, string four)
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                NamedEpisode(one, 1, 1, 1, new DateTime(2020, 1, 1)),
-                NamedEpisode(two, 2, 1, 3, new DateTime(2020, 1, 2)),
-                NamedEpisode(three, 1, 1, 2, new DateTime(2020, 1, 3)),
-                NamedEpisode(four, 1, 1, 5, new DateTime(2020, 1, 4))
-            };
-
-            List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, true);
-
-            result.Count.Should().Be(2);
-            ShouldHaveMultipleItems(result, mediaItems[0], new List<MediaItem> { mediaItems[1], mediaItems[2] });
-            ShouldHaveOneItem(result, mediaItems[3]);
-        }
-
-        private static Episode NamedEpisode(
-            string title,
-            int showId,
-            int season,
-            int episode,
-            DateTime? releaseDate = null) =>
-            new()
-            {
-                EpisodeMetadata = new List<EpisodeMetadata>
-                {
-                    new() { Title = title, ReleaseDate = releaseDate, EpisodeNumber = episode }
-                },
-                Season = new Season
-                {
-                    SeasonNumber = season,
-                    Show = new Show { Id = showId },
-                    ShowId = showId
-                }
-            };
-
-        private static void ShouldHaveOneItem(IEnumerable<GroupedMediaItem> result, MediaItem item) =>
-            result.Filter(g => g.First == item && Optional(g.Additional).Flatten().HeadOrNone() == None)
-                .Should().HaveCount(1);
-
-        private static void ShouldHaveTwoItems(
-            IEnumerable<GroupedMediaItem> result,
-            MediaItem first,
-            MediaItem additional) =>
-            result.Filter(g => g.First == first && Optional(g.Additional).Flatten().HeadOrNone() == Some(additional))
-                .Should().HaveCount(1);
-
-        private static void ShouldHaveMultipleItems(
-            IEnumerable<GroupedMediaItem> result,
-            MediaItem first,
-            List<MediaItem> additional) =>
-            result.Filter(
-                    g => g.First == first && g.Additional != null && g.Additional.Count == additional.Count &&
-                         additional.ForAll(g.Additional.Contains))
-                .Should().HaveCount(1);
+        result.Count.Should().Be(3);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[3]);
     }
-}
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 2 - Part 2", "Episode 3")]
+    [TestCase("Episode 1 Part 1", "Episode 2 (2) - More", "Episode 3 - After")]
+    [TestCase("Episode 1 Part 1", "Episode 2 (II)", "Episode 3")]
+    [TestCase("Episode 1 Part One", "Episode 2 (II)", "Episode 3")]
+    [TestCase("Episode 1 (1)", "Episode 2 (Part 2)", "Episode 3")]
+    public void MixedNaming_Group(string one, string two, string three)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(2);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (5)", "Episode 2 - (6)", "Episode 3")]
+    [TestCase("Episode 1 Part 5", "Episode 2 Part 6", "Episode 3 - After")]
+    [TestCase("Episode 1 Part (V)", "Episode 2 (VI)", "Episode 3")]
+    [TestCase("Episode 1 (Part 5)", "Episode 2 (Part 6)", "Episode 3")]
+    public void Only_Later_Parts(string one, string two, string three)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(2);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3")]
+    [TestCase("Episode 1 (1) - More", "Episode 2 (2) - Title", "Episode 3 - After")]
+    [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3")]
+    [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3")]
+    public void Grouped_NotGrouped(string one, string two, string three)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(2);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3", "Episode 4 (1)", "Episode 5 (2)")]
+    [TestCase(
+        "Episode 1 (1) - More",
+        "Episode 2 (2) - Title",
+        "Episode 3 - After",
+        "Episode 4 (1) - Dash",
+        "Episode 5 (2) - Again")]
+    [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3", "Episode 4 Part 1", "Episode 5 Part 2")]
+    [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3", "Episode 4 (Part 1)", "Episode 5 (Part 2)")]
+    public void Grouped_NotGrouped_Grouped(string one, string two, string three, string four, string five)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4),
+            NamedEpisode(five, 1, 1, 5)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+        ShouldHaveTwoItems(result, mediaItems[3], mediaItems[4]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 2 (2)", "Episode 3 (1)", "Episode 4 (2)")]
+    [TestCase("Episode 1 (1) - More", "Episode 2 (2) - Title", "Episode 3 (1) - After", "Episode 4 (2) - Dash")]
+    [TestCase("Episode 1 Part 1", "Episode 2 Part 2", "Episode 3 Part 1", "Episode 4 Part 2")]
+    [TestCase("Episode 1 (Part 1)", "Episode 2 (Part 2)", "Episode 3 (Part 1)", "Episode 4 (Part 2)")]
+    public void Grouped_Grouped(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(2);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[1]);
+        ShouldHaveTwoItems(result, mediaItems[2], mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("Episode 1", "Episode 2 (2)", "Episode 3 (1)", "Episode 4 (2)")]
+    [TestCase("Episode 1 - More", "Episode 2 (2) - Title", "Episode 3 (1) - After", "Episode 4 (2) - Dash")]
+    [TestCase("Episode 1", "Episode 2 Part 2", "Episode 3 Part 1", "Episode 4 Part 2")]
+    [TestCase("Episode 1", "Episode 2 (Part 2)", "Episode 3 (Part 1)", "Episode 4 (Part 2)")]
+    public void Part2_Without_Part1(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveOneItem(result, mediaItems[1]);
+        ShouldHaveTwoItems(result, mediaItems[2], mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("Episode 1", "Episode 2 (2)", "Episode 3 (3)", "Episode 4")]
+    [TestCase("Episode 1 - More", "Episode 2 (2) - Title", "Episode 3 (3) - After", "Episode 4 - Dash")]
+    [TestCase("Episode 1", "Episode 2 Part 2", "Episode 3 Part 3", "Episode 4")]
+    [TestCase("Episode 1", "Episode 2 (Part 2)", "Episode 3 (Part 3)", "Episode 4")]
+    public void Part2And3_Without_Part1(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 2),
+            NamedEpisode(three, 1, 1, 3),
+            NamedEpisode(four, 1, 1, 4)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 3 (3)", "Episode 4", "Episode 5")]
+    [TestCase("Episode 1 (1) - More", "Episode 3 (3) - Title", "Episode 4 - After", "Episode 5 - Dash")]
+    [TestCase("Episode 1 Part 1", "Episode 3 Part 3", "Episode 4", "Episode 5")]
+    [TestCase("Episode 1 (Part 1)", "Episode 3 (Part 3)", "Episode 4", "Episode 5")]
+    public void Skip_Part(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 3),
+            NamedEpisode(three, 1, 1, 4),
+            NamedEpisode(four, 1, 1, 5)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(4);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveOneItem(result, mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("Episode 1 (1)", "Episode 3 (1)", "Episode 4 (2)", "Episode 5")]
+    [TestCase("Episode 1 (1) - More", "Episode 3 (1) - Title", "Episode 4 (2) - After", "Episode 5 - Dash")]
+    [TestCase("Episode 1 Part 1", "Episode 3 Part 1", "Episode 4 Part 2", "Episode 5")]
+    [TestCase("Episode 1 (Part 1)", "Episode 3 (Part 1)", "Episode 4 (Part 2)", "Episode 5")]
+    public void Repeat_Part(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1),
+            NamedEpisode(two, 1, 1, 3),
+            NamedEpisode(three, 1, 1, 4),
+            NamedEpisode(four, 1, 1, 5)
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveOneItem(result, mediaItems[0]);
+        ShouldHaveTwoItems(result, mediaItems[1], mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("S1 Episode 1 (1)", "S2 Episode 3 (1)", "S1 Episode 2 (2)", "S1 Episode 5")]
+    [TestCase(
+        "S1 Episode 1 (1) - More",
+        "S2 Episode 3 (1) - Title",
+        "S1 Episode 2 (2) - After",
+        "S1 Episode 5 - Dash")]
+    [TestCase("S1 Episode 1 Part 1", "S2 Episode 3 Part 1", "S1 Episode 2 Part 2", "S1 Episode 5")]
+    [TestCase("S1 Episode 1 (Part 1)", "S2 Episode 3 (Part 1)", "S1 Episode 2 (Part 2)", "S1 Episode 5")]
+    public void Mixed_Shows_Chronologically(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1, new DateTime(2020, 1, 1)),
+            NamedEpisode(two, 2, 1, 3, new DateTime(2020, 1, 2)),
+            NamedEpisode(three, 1, 1, 2, new DateTime(2020, 1, 3)),
+            NamedEpisode(four, 1, 1, 5, new DateTime(2020, 1, 4))
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, false);
+
+        result.Count.Should().Be(3);
+        ShouldHaveTwoItems(result, mediaItems[0], mediaItems[2]);
+        ShouldHaveOneItem(result, mediaItems[1]);
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    [Test]
+    [TestCase("S1 Episode 1 (1)", "S2 Episode 3 (2)", "S1 Episode 2 (3)", "S1 Episode 5")]
+    [TestCase(
+        "S1 Episode 1 (1) - More",
+        "S2 Episode 3 (2) - Title",
+        "S1 Episode 2 (3) - After",
+        "S1 Episode 5 - Dash")]
+    [TestCase("S1 Episode 1 Part 1", "S2 Episode 3 Part 2", "S1 Episode 2 Part 3", "S1 Episode 5")]
+    [TestCase("S1 Episode 1 (Part 1)", "S2 Episode 3 (Part 2)", "S1 Episode 2 (Part 3)", "S1 Episode 5")]
+    public void Mixed_Shows_Chronologically_Crossover(string one, string two, string three, string four)
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            NamedEpisode(one, 1, 1, 1, new DateTime(2020, 1, 1)),
+            NamedEpisode(two, 2, 1, 3, new DateTime(2020, 1, 2)),
+            NamedEpisode(three, 1, 1, 2, new DateTime(2020, 1, 3)),
+            NamedEpisode(four, 1, 1, 5, new DateTime(2020, 1, 4))
+        };
+
+        List<GroupedMediaItem> result = MultiPartEpisodeGrouper.GroupMediaItems(mediaItems, true);
+
+        result.Count.Should().Be(2);
+        ShouldHaveMultipleItems(result, mediaItems[0], new List<MediaItem> { mediaItems[1], mediaItems[2] });
+        ShouldHaveOneItem(result, mediaItems[3]);
+    }
+
+    private static Episode NamedEpisode(
+        string title,
+        int showId,
+        int season,
+        int episode,
+        DateTime? releaseDate = null) =>
+        new()
+        {
+            EpisodeMetadata = new List<EpisodeMetadata>
+            {
+                new() { Title = title, ReleaseDate = releaseDate, EpisodeNumber = episode }
+            },
+            Season = new Season
+            {
+                SeasonNumber = season,
+                Show = new Show { Id = showId },
+                ShowId = showId
+            }
+        };
+
+    private static void ShouldHaveOneItem(IEnumerable<GroupedMediaItem> result, MediaItem item) =>
+        result.Filter(g => g.First == item && Optional(g.Additional).Flatten().HeadOrNone() == None)
+            .Should().HaveCount(1);
+
+    private static void ShouldHaveTwoItems(
+        IEnumerable<GroupedMediaItem> result,
+        MediaItem first,
+        MediaItem additional) =>
+        result.Filter(g => g.First == first && Optional(g.Additional).Flatten().HeadOrNone() == Some(additional))
+            .Should().HaveCount(1);
+
+    private static void ShouldHaveMultipleItems(
+        IEnumerable<GroupedMediaItem> result,
+        MediaItem first,
+        List<MediaItem> additional) =>
+        result.Filter(
+                g => g.First == first && g.Additional != null && g.Additional.Count == additional.Count &&
+                     additional.ForAll(g.Additional.Contains))
+            .Should().HaveCount(1);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs b/ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs
index 69d8b26ac..37acd7dc1 100644
--- a/ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/PlayoutBuilderTests.cs
@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Scheduling;
@@ -13,1425 +9,1423 @@ using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 using Serilog;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class PlayoutBuilderTests
 {
-    [TestFixture]
-    public class PlayoutBuilderTests
+    private readonly ILogger<PlayoutBuilder> _logger;
+
+    public PlayoutBuilderTests()
     {
-        private readonly ILogger<PlayoutBuilder> _logger;
-
-        public PlayoutBuilderTests()
+        if (Log.Logger.GetType().FullName == "Serilog.Core.Pipeline.SilentLogger")
         {
-            if (Log.Logger.GetType().FullName == "Serilog.Core.Pipeline.SilentLogger")
-            {
-                Log.Logger = new LoggerConfiguration().MinimumLevel.Debug().WriteTo.Console().CreateLogger();
-                Log.Logger.Debug(
-                    "Logger is not configured. Either this is a unit test or you have to configure the logger");
-            }
-
-            ServiceProvider serviceProvider = new ServiceCollection()
-                .AddLogging(builder => builder.AddSerilog(dispose: true))
-                .BuildServiceProvider();
-
-            ILoggerFactory factory = serviceProvider.GetService<ILoggerFactory>();
-
-            _logger = factory.CreateLogger<PlayoutBuilder>();
+            Log.Logger = new LoggerConfiguration().MinimumLevel.Debug().WriteTo.Console().CreateLogger();
+            Log.Logger.Debug(
+                "Logger is not configured. Either this is a unit test or you have to configure the logger");
         }
 
-        [Test]
-        [Timeout(2000)]
-        public async Task OnlyZeroDurationItem_Should_Abort()
+        ServiceProvider serviceProvider = new ServiceCollection()
+            .AddLogging(builder => builder.AddSerilog(dispose: true))
+            .BuildServiceProvider();
+
+        ILoggerFactory factory = serviceProvider.GetService<ILoggerFactory>();
+
+        _logger = factory.CreateLogger<PlayoutBuilder>();
+    }
+
+    [Test]
+    [Timeout(2000)]
+    public async Task OnlyZeroDurationItem_Should_Abort()
+    {
+        var mediaItems = new List<MediaItem>
         {
-            var mediaItems = new List<MediaItem>
-            {
-                TestMovie(1, TimeSpan.Zero, DateTime.Today)
-            };
+            TestMovie(1, TimeSpan.Zero, DateTime.Today)
+        };
 
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Random);
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Random);
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
 
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
 
-            result.Items.Should().BeNull();
-        }
+        result.Items.Should().BeNull();
+    }
 
-        [Test]
-        public async Task ZeroDurationItem_Should_BeSkipped()
+    [Test]
+    public async Task ZeroDurationItem_Should_BeSkipped()
+    {
+        var mediaItems = new List<MediaItem>
         {
-            var mediaItems = new List<MediaItem>
-            {
-                TestMovie(1, TimeSpan.Zero, DateTime.Today),
-                TestMovie(2, TimeSpan.FromHours(6), DateTime.Today)
-            };
+            TestMovie(1, TimeSpan.Zero, DateTime.Today),
+            TestMovie(2, TimeSpan.FromHours(6), DateTime.Today)
+        };
 
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Random);
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Random);
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
 
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
 
-            result.Items.Count.Should().Be(1);
-            result.Items.Head().MediaItemId.Should().Be(2);
-            result.Items.Head().StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
-            result.Items.Head().FinishOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
-        }
+        result.Items.Count.Should().Be(1);
+        result.Items.Head().MediaItemId.Should().Be(2);
+        result.Items.Head().StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
+        result.Items.Head().FinishOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
+    }
 
-        [Test]
-        public async Task InitialFlood_Should_StartAtMidnight()
+    [Test]
+    public async Task InitialFlood_Should_StartAtMidnight()
+    {
+        var mediaItems = new List<MediaItem>
         {
-            var mediaItems = new List<MediaItem>
-            {
-                TestMovie(1, TimeSpan.FromHours(6), DateTime.Today)
-            };
+            TestMovie(1, TimeSpan.FromHours(6), DateTime.Today)
+        };
 
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Random);
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Random);
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
 
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
 
-            result.Items.Count.Should().Be(1);
-            result.Items.Head().StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
-            result.Items.Head().FinishOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
-        }
+        result.Items.Count.Should().Be(1);
+        result.Items.Head().StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
+        result.Items.Head().FinishOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
+    }
 
-        [Test]
-        public async Task InitialFlood_Should_StartAtMidnight_With_LateStart()
+    [Test]
+    public async Task InitialFlood_Should_StartAtMidnight_With_LateStart()
+    {
+        var mediaItems = new List<MediaItem>
         {
-            var mediaItems = new List<MediaItem>
-            {
-                TestMovie(1, TimeSpan.FromHours(6), DateTime.Today)
-            };
+            TestMovie(1, TimeSpan.FromHours(6), DateTime.Today)
+        };
 
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Random);
-            DateTimeOffset start = HoursAfterMidnight(1);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Random);
+        DateTimeOffset start = HoursAfterMidnight(1);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
 
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
 
-            result.Items.Count.Should().Be(2);
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
-            result.Items[1].FinishOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(12));
-        }
+        result.Items.Count.Should().Be(2);
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
+        result.Items[1].FinishOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(12));
+    }
 
-        [Test]
-        public async Task ChronologicalContent_Should_CreateChronologicalItems()
+    [Test]
+    public async Task ChronologicalContent_Should_CreateChronologicalItems()
+    {
+        var mediaItems = new List<MediaItem>
         {
-            var mediaItems = new List<MediaItem>
+            TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+            TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
+        };
+
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Chronological);
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(4);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(4);
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[1].MediaItemId.Should().Be(2);
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[2].MediaItemId.Should().Be(1);
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+        result.Items[3].MediaItemId.Should().Be(2);
+    }
+
+    [Test]
+    public async Task ChronologicalFlood_Should_AnchorAndMaintainExistingPlayout()
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            TestMovie(1, TimeSpan.FromHours(6), DateTime.Today),
+            TestMovie(2, TimeSpan.FromHours(6), DateTime.Today.AddHours(1))
+        };
+
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Chronological);
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(1);
+        result.Items.Head().MediaItemId.Should().Be(1);
+
+        result.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(6));
+
+        result.ProgramScheduleAnchors.Count.Should().Be(1);
+        result.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(1);
+
+        DateTimeOffset start2 = HoursAfterMidnight(1);
+        DateTimeOffset finish2 = start2 + TimeSpan.FromHours(6);
+
+        Playout result2 = await builder.BuildPlayoutItems(playout, start2, finish2);
+
+        result2.Items.Count.Should().Be(2);
+        result2.Items.Last().StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
+        result2.Items.Last().MediaItemId.Should().Be(2);
+
+        result2.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(12));
+        result2.ProgramScheduleAnchors.Count.Should().Be(1);
+        result2.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(0);
+    }
+
+    [Test]
+    public async Task ChronologicalFlood_Should_AnchorAndReturnNewPlayoutItems()
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            TestMovie(1, TimeSpan.FromHours(6), DateTime.Today),
+            TestMovie(2, TimeSpan.FromHours(6), DateTime.Today.AddHours(1))
+        };
+
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Chronological);
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(1);
+        result.Items.Head().MediaItemId.Should().Be(1);
+
+        result.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(6));
+        result.ProgramScheduleAnchors.Count.Should().Be(1);
+        result.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(1);
+
+        DateTimeOffset start2 = HoursAfterMidnight(1);
+        DateTimeOffset finish2 = start2 + TimeSpan.FromHours(12);
+
+        Playout result2 = await builder.BuildPlayoutItems(playout, start2, finish2);
+
+        result2.Items.Count.Should().Be(3);
+        result2.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
+        result2.Items[1].MediaItemId.Should().Be(2);
+        result2.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(12));
+        result2.Items[2].MediaItemId.Should().Be(1);
+
+        result2.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(18));
+        result2.ProgramScheduleAnchors.Count.Should().Be(1);
+        result2.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(1);
+    }
+
+    [Test]
+    public async Task ShuffleFloodRebuild_Should_IgnoreAnchors()
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            TestMovie(1, TimeSpan.FromHours(1), DateTime.Today),
+            TestMovie(2, TimeSpan.FromHours(1), DateTime.Today.AddHours(1)),
+            TestMovie(3, TimeSpan.FromHours(1), DateTime.Today.AddHours(2)),
+            TestMovie(4, TimeSpan.FromHours(1), DateTime.Today.AddHours(3)),
+            TestMovie(5, TimeSpan.FromHours(1), DateTime.Today.AddHours(4)),
+            TestMovie(6, TimeSpan.FromHours(1), DateTime.Today.AddHours(5))
+        };
+
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Shuffle);
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(6);
+        result.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(6));
+
+        result.ProgramScheduleAnchors.Count.Should().Be(1);
+        result.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(0);
+
+        int firstSeedValue = result.ProgramScheduleAnchors.Head().EnumeratorState.Seed;
+
+        DateTimeOffset start2 = HoursAfterMidnight(0);
+        DateTimeOffset finish2 = start2 + TimeSpan.FromHours(6);
+
+        Playout result2 = await builder.BuildPlayoutItems(playout, start2, finish2, true);
+
+        result2.Items.Count.Should().Be(6);
+        result2.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(6));
+
+        result2.ProgramScheduleAnchors.Count.Should().Be(1);
+        result2.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(0);
+
+        int secondSeedValue = result2.ProgramScheduleAnchors.Head().EnumeratorState.Seed;
+
+        firstSeedValue.Should().NotBe(secondSeedValue);
+    }
+
+    [Test]
+    public async Task ShuffleFlood_Should_MaintainRandomSeed()
+    {
+        var mediaItems = new List<MediaItem>
+        {
+            TestMovie(1, TimeSpan.FromHours(1), DateTime.Today),
+            TestMovie(2, TimeSpan.FromHours(1), DateTime.Today.AddHours(1)),
+            TestMovie(3, TimeSpan.FromHours(1), DateTime.Today.AddHours(3))
+        };
+
+        (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Shuffle);
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(6);
+        result.ProgramScheduleAnchors.Count.Should().Be(1);
+        result.ProgramScheduleAnchors.Head().EnumeratorState.Seed.Should().BeGreaterThan(0);
+
+        int firstSeedValue = result.ProgramScheduleAnchors.Head().EnumeratorState.Seed;
+
+        DateTimeOffset start2 = HoursAfterMidnight(0);
+        DateTimeOffset finish2 = start2 + TimeSpan.FromHours(6);
+
+        Playout result2 = await builder.BuildPlayoutItems(playout, start2, finish2);
+
+        int secondSeedValue = result2.ProgramScheduleAnchors.Head().EnumeratorState.Seed;
+
+        firstSeedValue.Should().Be(secondSeedValue);
+    }
+
+    [Test]
+    public async Task FloodContent_Should_FloodAroundFixedContent_One()
+    {
+        var floodCollection = new Collection
+        {
+            Id = 1,
+            Name = "Flood Items",
+            MediaItems = new List<MediaItem>
             {
                 TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
                 TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
-            };
+            }
+        };
 
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Chronological);
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(4);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(4);
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[1].MediaItemId.Should().Be(2);
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[2].MediaItemId.Should().Be(1);
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
-            result.Items[3].MediaItemId.Should().Be(2);
-        }
-
-        [Test]
-        public async Task ChronologicalFlood_Should_AnchorAndMaintainExistingPlayout()
+        var fixedCollection = new Collection
         {
-            var mediaItems = new List<MediaItem>
+            Id = 2,
+            Name = "Fixed Items",
+            MediaItems = new List<MediaItem>
             {
-                TestMovie(1, TimeSpan.FromHours(6), DateTime.Today),
-                TestMovie(2, TimeSpan.FromHours(6), DateTime.Today.AddHours(1))
-            };
+                TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1))
+            }
+        };
 
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Chronological);
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (floodCollection.Id, floodCollection.MediaItems.ToList()),
+                (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
 
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(1);
-            result.Items.Head().MediaItemId.Should().Be(1);
-
-            result.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(6));
-
-            result.ProgramScheduleAnchors.Count.Should().Be(1);
-            result.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(1);
-
-            DateTimeOffset start2 = HoursAfterMidnight(1);
-            DateTimeOffset finish2 = start2 + TimeSpan.FromHours(6);
-
-            Playout result2 = await builder.BuildPlayoutItems(playout, start2, finish2);
-
-            result2.Items.Count.Should().Be(2);
-            result2.Items.Last().StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
-            result2.Items.Last().MediaItemId.Should().Be(2);
-
-            result2.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(12));
-            result2.ProgramScheduleAnchors.Count.Should().Be(1);
-            result2.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(0);
-        }
-
-        [Test]
-        public async Task ChronologicalFlood_Should_AnchorAndReturnNewPlayoutItems()
+        var items = new List<ProgramScheduleItem>
         {
-            var mediaItems = new List<MediaItem>
-            {
-                TestMovie(1, TimeSpan.FromHours(6), DateTime.Today),
-                TestMovie(2, TimeSpan.FromHours(6), DateTime.Today.AddHours(1))
-            };
-
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Chronological);
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(1);
-            result.Items.Head().MediaItemId.Should().Be(1);
-
-            result.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(6));
-            result.ProgramScheduleAnchors.Count.Should().Be(1);
-            result.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(1);
-
-            DateTimeOffset start2 = HoursAfterMidnight(1);
-            DateTimeOffset finish2 = start2 + TimeSpan.FromHours(12);
-
-            Playout result2 = await builder.BuildPlayoutItems(playout, start2, finish2);
-
-            result2.Items.Count.Should().Be(3);
-            result2.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
-            result2.Items[1].MediaItemId.Should().Be(2);
-            result2.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(12));
-            result2.Items[2].MediaItemId.Should().Be(1);
-
-            result2.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(18));
-            result2.ProgramScheduleAnchors.Count.Should().Be(1);
-            result2.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(1);
-        }
-
-        [Test]
-        public async Task ShuffleFloodRebuild_Should_IgnoreAnchors()
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                TestMovie(1, TimeSpan.FromHours(1), DateTime.Today),
-                TestMovie(2, TimeSpan.FromHours(1), DateTime.Today.AddHours(1)),
-                TestMovie(3, TimeSpan.FromHours(1), DateTime.Today.AddHours(2)),
-                TestMovie(4, TimeSpan.FromHours(1), DateTime.Today.AddHours(3)),
-                TestMovie(5, TimeSpan.FromHours(1), DateTime.Today.AddHours(4)),
-                TestMovie(6, TimeSpan.FromHours(1), DateTime.Today.AddHours(5))
-            };
-
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Shuffle);
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(6);
-            result.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(6));
-
-            result.ProgramScheduleAnchors.Count.Should().Be(1);
-            result.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(0);
-
-            int firstSeedValue = result.ProgramScheduleAnchors.Head().EnumeratorState.Seed;
-
-            DateTimeOffset start2 = HoursAfterMidnight(0);
-            DateTimeOffset finish2 = start2 + TimeSpan.FromHours(6);
-
-            Playout result2 = await builder.BuildPlayoutItems(playout, start2, finish2, true);
-
-            result2.Items.Count.Should().Be(6);
-            result2.Anchor.NextStartOffset.Should().Be(DateTime.Today.AddHours(6));
-
-            result2.ProgramScheduleAnchors.Count.Should().Be(1);
-            result2.ProgramScheduleAnchors.Head().EnumeratorState.Index.Should().Be(0);
-
-            int secondSeedValue = result2.ProgramScheduleAnchors.Head().EnumeratorState.Seed;
-
-            firstSeedValue.Should().NotBe(secondSeedValue);
-        }
-
-        [Test]
-        public async Task ShuffleFlood_Should_MaintainRandomSeed()
-        {
-            var mediaItems = new List<MediaItem>
-            {
-                TestMovie(1, TimeSpan.FromHours(1), DateTime.Today),
-                TestMovie(2, TimeSpan.FromHours(1), DateTime.Today.AddHours(1)),
-                TestMovie(3, TimeSpan.FromHours(1), DateTime.Today.AddHours(3))
-            };
-
-            (PlayoutBuilder builder, Playout playout) = TestDataFloodForItems(mediaItems, PlaybackOrder.Shuffle);
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(6);
-            result.ProgramScheduleAnchors.Count.Should().Be(1);
-            result.ProgramScheduleAnchors.Head().EnumeratorState.Seed.Should().BeGreaterThan(0);
-
-            int firstSeedValue = result.ProgramScheduleAnchors.Head().EnumeratorState.Seed;
-
-            DateTimeOffset start2 = HoursAfterMidnight(0);
-            DateTimeOffset finish2 = start2 + TimeSpan.FromHours(6);
-
-            Playout result2 = await builder.BuildPlayoutItems(playout, start2, finish2);
-
-            int secondSeedValue = result2.ProgramScheduleAnchors.Head().EnumeratorState.Seed;
-
-            firstSeedValue.Should().Be(secondSeedValue);
-        }
-
-        [Test]
-        public async Task FloodContent_Should_FloodAroundFixedContent_One()
-        {
-            var floodCollection = new Collection
-            {
-                Id = 1,
-                Name = "Flood Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
-                }
-            };
-
-            var fixedCollection = new Collection
-            {
-                Id = 2,
-                Name = "Fixed Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1))
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (floodCollection.Id, floodCollection.MediaItems.ToList()),
-                    (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemFlood
-                {
-                    Index = 1,
-                    Collection = floodCollection,
-                    CollectionId = floodCollection.Id,
-                    StartTime = null,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemOne
-                {
-                    Index = 2,
-                    Collection = fixedCollection,
-                    CollectionId = fixedCollection.Id,
-                    StartTime = TimeSpan.FromHours(3),
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(5);
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[1].MediaItemId.Should().Be(2);
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[2].MediaItemId.Should().Be(1);
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
-            result.Items[3].MediaItemId.Should().Be(3);
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5));
-            result.Items[4].MediaItemId.Should().Be(2);
-        }
-
-        [Test]
-        public async Task FloodContent_Should_FloodAroundFixedContent_Multiple()
-        {
-            var floodCollection = new Collection
-            {
-                Id = 1,
-                Name = "Flood Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
-                }
-            };
-
-            var fixedCollection = new Collection
-            {
-                Id = 2,
-                Name = "Fixed Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
-                    TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 2))
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (floodCollection.Id, floodCollection.MediaItems.ToList()),
-                    (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemFlood
-                {
-                    Index = 1,
-                    Collection = floodCollection,
-                    CollectionId = floodCollection.Id,
-                    StartTime = null,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemMultiple
-                {
-                    Index = 2,
-                    Collection = fixedCollection,
-                    CollectionId = fixedCollection.Id,
-                    StartTime = TimeSpan.FromHours(3),
-                    Count = 2,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(7);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(6);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[1].MediaItemId.Should().Be(2);
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[2].MediaItemId.Should().Be(1);
-
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
-            result.Items[3].MediaItemId.Should().Be(3);
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5));
-            result.Items[4].MediaItemId.Should().Be(4);
-
-            result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
-            result.Items[5].MediaItemId.Should().Be(2);
-        }
-
-        [Test]
-        public async Task FloodContent_Should_FloodWithFixedStartTime()
-        {
-            var floodCollection = new Collection
-            {
-                Id = 1,
-                Name = "Flood Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
-                }
-            };
-
-            var fixedCollection = new Collection
-            {
-                Id = 2,
-                Name = "Fixed Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
-                    TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 2))
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (floodCollection.Id, floodCollection.MediaItems.ToList()),
-                    (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemFlood
-                {
-                    Index = 1,
-                    Collection = floodCollection,
-                    CollectionId = floodCollection.Id,
-                    StartTime = TimeSpan.FromHours(7),
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemOne
-                {
-                    Index = 2,
-                    Collection = fixedCollection,
-                    CollectionId = fixedCollection.Id,
-                    StartTime = TimeSpan.FromHours(12),
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(24);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(6);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(7));
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(8));
-            result.Items[1].MediaItemId.Should().Be(2);
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(9));
-            result.Items[2].MediaItemId.Should().Be(1);
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(10));
-            result.Items[3].MediaItemId.Should().Be(2);
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(11));
-            result.Items[4].MediaItemId.Should().Be(1);
-
-            result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(12));
-            result.Items[5].MediaItemId.Should().Be(3);
-        }
-
-        [Test]
-        public async Task FloodContent_Should_FloodWithFixedStartTime_FromAnchor()
-        {
-            var floodCollection = new Collection
-            {
-                Id = 1,
-                Name = "Flood Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
-                }
-            };
-
-            var fixedCollection = new Collection
-            {
-                Id = 2,
-                Name = "Fixed Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
-                    TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 2))
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (floodCollection.Id, floodCollection.MediaItems.ToList()),
-                    (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemFlood
-                {
-                    Index = 1,
-                    Collection = floodCollection,
-                    CollectionId = floodCollection.Id,
-                    StartTime = TimeSpan.FromHours(7),
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemOne
-                {
-                    Index = 2,
-                    Collection = fixedCollection,
-                    CollectionId = fixedCollection.Id,
-                    StartTime = TimeSpan.FromHours(12),
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
-                Anchor = new PlayoutAnchor
-                {
-                    NextStart = HoursAfterMidnight(9).UtcDateTime,
-                    ScheduleItemsEnumeratorState = new CollectionEnumeratorState
-                    {
-                        Index = 0,
-                        Seed = 1
-                    },
-                    InFlood = true
-                }
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(32);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(5);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(9));
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(10));
-            result.Items[1].MediaItemId.Should().Be(2);
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(11));
-            result.Items[2].MediaItemId.Should().Be(1);
-
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(12));
-            result.Items[3].MediaItemId.Should().Be(3);
-
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(7));
-            result.Items[4].MediaItemId.Should().Be(2);
-
-            result.Anchor.InFlood.Should().BeTrue();
-        }
-
-        [Test]
-        public async Task FloodContent_Should_FloodAroundFixedContent_DurationWithoutOfflineTail()
-        {
-            var floodCollection = new Collection
-            {
-                Id = 1,
-                Name = "Flood Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
-                }
-            };
-
-            var fixedCollection = new Collection
-            {
-                Id = 2,
-                Name = "Fixed Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(3, TimeSpan.FromHours(0.75), new DateTime(2020, 1, 1)),
-                    TestMovie(4, TimeSpan.FromHours(1.5), new DateTime(2020, 1, 2))
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (floodCollection.Id, floodCollection.MediaItems.ToList()),
-                    (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemFlood
-                {
-                    Index = 1,
-                    Collection = floodCollection,
-                    CollectionId = floodCollection.Id,
-                    StartTime = null,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemDuration
-                {
-                    Index = 2,
-                    Collection = fixedCollection,
-                    CollectionId = fixedCollection.Id,
-                    StartTime = TimeSpan.FromHours(2),
-                    PlayoutDuration = TimeSpan.FromHours(2),
-                    TailMode = TailMode.None, // immediately continue
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(7);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[1].MediaItemId.Should().Be(2);
-
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[2].MediaItemId.Should().Be(3);
-
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2.75));
-            result.Items[3].MediaItemId.Should().Be(1);
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3.75));
-            result.Items[4].MediaItemId.Should().Be(2);
-
-            result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4.75));
-            result.Items[5].MediaItemId.Should().Be(1);
-            result.Items[6].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5.75));
-            result.Items[6].MediaItemId.Should().Be(2);
-        }
-
-        [Test]
-        public async Task MultipleContent_Should_WrapAroundDynamicContent_DurationWithoutOfflineTail()
-        {
-            var multipleCollection = new Collection
-            {
-                Id = 1,
-                Name = "Multiple Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
-                }
-            };
-
-            var dynamicCollection = new Collection
-            {
-                Id = 2,
-                Name = "Dynamic Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(3, TimeSpan.FromHours(0.75), new DateTime(2020, 1, 1)),
-                    TestMovie(4, TimeSpan.FromHours(1.5), new DateTime(2020, 1, 2))
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (multipleCollection.Id, multipleCollection.MediaItems.ToList()),
-                    (dynamicCollection.Id, dynamicCollection.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemMultiple
-                {
-                    Index = 1,
-                    Collection = multipleCollection,
-                    CollectionId = multipleCollection.Id,
-                    StartTime = null,
-                    Count = 2,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemDuration
-                {
-                    Index = 2,
-                    Collection = dynamicCollection,
-                    CollectionId = dynamicCollection.Id,
-                    StartTime = null,
-                    PlayoutDuration = TimeSpan.FromHours(2),
-                    TailMode = TailMode.None, // immediately continue
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(6);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[1].MediaItemId.Should().Be(2);
-
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[2].MediaItemId.Should().Be(3);
-
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2.75));
-            result.Items[3].MediaItemId.Should().Be(1);
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3.75));
-            result.Items[4].MediaItemId.Should().Be(2);
-
-            result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4.75));
-            result.Items[5].MediaItemId.Should().Be(4);
-        }
-
-        [Test]
-        public async Task Alternating_MultipleContent_Should_Maintain_Counts()
-        {
-            var collectionOne = new Collection
-            {
-                Id = 1,
-                Name = "Multiple Items 1",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
-                }
-            };
-
-            var collectionTwo = new Collection
-            {
-                Id = 2,
-                Name = "Multiple Items 2",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (collectionOne.Id, collectionOne.MediaItems.ToList()),
-                    (collectionTwo.Id, collectionTwo.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemMultiple
-                {
-                    Id = 1,
-                    Index = 1,
-                    Collection = collectionOne,
-                    CollectionId = collectionOne.Id,
-                    StartTime = null,
-                    Count = 3,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemMultiple
-                {
-                    Id = 2,
-                    Index = 2,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id,
-                    StartTime = null,
-                    Count = 3,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
-                Anchor = new PlayoutAnchor
-                {
-                    NextStart = HoursAfterMidnight(1).UtcDateTime,
-                    ScheduleItemsEnumeratorState = new CollectionEnumeratorState
-                    {
-                        Index = 0,
-                        Seed = 1
-                    },
-                    MultipleRemaining = 2
-                }
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(5);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(4);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[1].MediaItemId.Should().Be(1);
-
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
-            result.Items[2].MediaItemId.Should().Be(2);
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
-            result.Items[3].MediaItemId.Should().Be(2);
-
-            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(1);
-            result.Anchor.MultipleRemaining.Should().Be(1);
-        }
-
-        [Test]
-        public async Task Auto_Zero_MultipleCount()
-        {
-            var collectionOne = new Collection
-            {
-                Id = 1,
-                Name = "Multiple Items 1",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(3, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
-                }
-            };
-
-            var collectionTwo = new Collection
-            {
-                Id = 2,
-                Name = "Multiple Items 2",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(5, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (collectionOne.Id, collectionOne.MediaItems.ToList()),
-                    (collectionTwo.Id, collectionTwo.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemMultiple
-                {
-                    Id = 1,
-                    Index = 1,
-                    Collection = collectionOne,
-                    CollectionId = collectionOne.Id,
-                    StartTime = null,
-                    Count = 0,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemMultiple
-                {
-                    Id = 2,
-                    Index = 2,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id,
-                    StartTime = null,
-                    Count = 0,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(5);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(5);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(0));
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[1].MediaItemId.Should().Be(2);
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[2].MediaItemId.Should().Be(3);
-            
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
-            result.Items[3].MediaItemId.Should().Be(4);
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
-            result.Items[4].MediaItemId.Should().Be(5);
-
-            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
-            result.Anchor.MultipleRemaining.Should().BeNull();
-        }
-
-        [Test]
-        public async Task Alternating_Duration_Should_Maintain_Duration()
-        {
-            var collectionOne = new Collection
-            {
-                Id = 1,
-                Name = "Duration Items 1",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
-                }
-            };
-
-            var collectionTwo = new Collection
-            {
-                Id = 2,
-                Name = "Duration Items 2",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
-                }
-            };
-
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (collectionOne.Id, collectionOne.MediaItems.ToList()),
-                    (collectionTwo.Id, collectionTwo.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemDuration
-                {
-                    Id = 1,
-                    Index = 1,
-                    Collection = collectionOne,
-                    CollectionId = collectionOne.Id,
-                    StartTime = null,
-                    PlayoutDuration = TimeSpan.FromHours(3),
-                    TailMode = TailMode.None,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                },
-                new ProgramScheduleItemDuration
-                {
-                    Id = 2,
-                    Index = 2,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id,
-                    StartTime = null,
-                    PlayoutDuration = TimeSpan.FromHours(3),
-                    TailMode = TailMode.None,
-                    PlaybackOrder = PlaybackOrder.Chronological
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
-                Anchor = new PlayoutAnchor
-                {
-                    NextStart = HoursAfterMidnight(1).UtcDateTime,
-                    ScheduleItemsEnumeratorState = new CollectionEnumeratorState
-                    {
-                        Index = 0,
-                        Seed = 1
-                    },
-                    DurationFinish = HoursAfterMidnight(3).UtcDateTime
-                }
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(5);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(4);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[1].MediaItemId.Should().Be(1);
-
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
-            result.Items[2].MediaItemId.Should().Be(2);
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
-            result.Items[3].MediaItemId.Should().Be(2);
-
-            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(1);
-            result.Anchor.DurationFinish.Should().Be(HoursAfterMidnight(6).UtcDateTime);
-        }
-        
-        [Test]
-        public async Task Alternating_Duration_With_Filler_Should_Alternate_Schedule_Items()
-        {
-            var collectionOne = new Collection
-            {
-                Id = 1,
-                Name = "Duration Items 1",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromMinutes(55), new DateTime(2020, 1, 1))
-                }
-            };
-            
-            var collectionTwo = new Collection
-            {
-                Id = 2,
-                Name = "Duration Items 2",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(2, TimeSpan.FromMinutes(55), new DateTime(2020, 1, 1))
-                }
-            };
-            
-            var collectionThree = new Collection
-            {
-                Id = 3,
-                Name = "Filler Items",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(3, TimeSpan.FromMinutes(5), new DateTime(2020, 1, 1))
-                }
-            };
-            
-            var fakeRepository = new FakeMediaCollectionRepository(
-                Map(
-                    (collectionOne.Id, collectionOne.MediaItems.ToList()),
-                    (collectionTwo.Id, collectionTwo.MediaItems.ToList()),
-                    (collectionThree.Id, collectionThree.MediaItems.ToList())));
-            
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemDuration
-                {
-                    Id = 1,
-                    Index = 1,
-                    Collection = collectionOne,
-                    CollectionId = collectionOne.Id,
-                    StartTime = null,
-                    PlayoutDuration = TimeSpan.FromHours(3),
-                    PlaybackOrder = PlaybackOrder.Chronological,
-                    TailMode = TailMode.Filler,
-                    TailFiller = new FillerPreset
-                    {
-                        FillerKind = FillerKind.Tail,
-                        Collection = collectionThree,
-                        CollectionId = collectionThree.Id
-                    }
-                },
-                new ProgramScheduleItemDuration
-                {
-                    Id = 2,
-                    Index = 2,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id,
-                    StartTime = null,
-                    PlayoutDuration = TimeSpan.FromHours(3),
-                    PlaybackOrder = PlaybackOrder.Chronological,
-                    TailMode = TailMode.Filler,
-                    TailFiller = new FillerPreset
-                    {
-                        FillerKind = FillerKind.Tail,
-                        Collection = collectionThree,
-                        CollectionId = collectionThree.Id
-                    }
-                }
-            };
-            
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
-            };
-            
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-            
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
-            
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-            
-            result.Items.Count.Should().Be(12);
-            
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromMinutes(0));
-            result.Items[0].MediaItemId.Should().Be(1);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromMinutes(55));
-            result.Items[1].MediaItemId.Should().Be(1);
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(new TimeSpan(1, 50, 0));
-            result.Items[2].MediaItemId.Should().Be(1);
-            
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 45, 0));
-            result.Items[3].MediaItemId.Should().Be(3);
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 50, 0));
-            result.Items[4].MediaItemId.Should().Be(3);
-            result.Items[5].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 55, 0));
-            result.Items[5].MediaItemId.Should().Be(3);
-            
-            result.Items[6].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
-            result.Items[6].MediaItemId.Should().Be(2);
-            result.Items[7].StartOffset.TimeOfDay.Should().Be(new TimeSpan(3, 55, 0));
-            result.Items[7].MediaItemId.Should().Be(2);
-            result.Items[8].StartOffset.TimeOfDay.Should().Be(new TimeSpan(4, 50, 0));
-            result.Items[8].MediaItemId.Should().Be(2);
-            
-            result.Items[9].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 45, 0));
-            result.Items[9].MediaItemId.Should().Be(3);
-            result.Items[10].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 50, 0));
-            result.Items[10].MediaItemId.Should().Be(3);
-            result.Items[11].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 55, 0));
-            result.Items[11].MediaItemId.Should().Be(3);
-            
-            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
-            result.Anchor.DurationFinish.Should().BeNull();
-        }
-        
-        [Test]
-        public async Task Duration_Should_Skip_Items_That_Are_Too_Long()
-        {
-            var collectionOne = new Collection
-            {
-                Id = 1,
-                Name = "Duration Items 1",
-                MediaItems = new List<MediaItem>
-                {
-                    TestMovie(1, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
-                    TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
-                    TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
-                    TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
-                }
-            };
-
-            var fakeRepository =
-                new FakeMediaCollectionRepository(Map((collectionOne.Id, collectionOne.MediaItems.ToList())));
-
-            var items = new List<ProgramScheduleItem>
-            {
-                new ProgramScheduleItemDuration
-                {
-                    Id = 1,
-                    Index = 1,
-                    Collection = collectionOne,
-                    CollectionId = collectionOne.Id,
-                    StartTime = null,
-                    PlayoutDuration = TimeSpan.FromHours(1),
-                    PlaybackOrder = PlaybackOrder.Chronological,
-                    TailMode = TailMode.None,
-                }
-            };
-
-            var playout = new Playout
-            {
-                ProgramSchedule = new ProgramSchedule
-                {
-                    Items = items
-                },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
-            };
-
-            var configRepo = new Mock<IConfigElementRepository>();
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                fakeRepository,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
-
-            DateTimeOffset start = HoursAfterMidnight(0);
-            DateTimeOffset finish = start + TimeSpan.FromHours(6);
-
-            Playout result = await builder.BuildPlayoutItems(playout, start, finish);
-
-            result.Items.Count.Should().Be(6);
-
-            result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(0));
-            result.Items[0].MediaItemId.Should().Be(2);
-            result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
-            result.Items[1].MediaItemId.Should().Be(4);
-            result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
-            result.Items[2].MediaItemId.Should().Be(2);
-            result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
-            result.Items[3].MediaItemId.Should().Be(4);
-            result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
-            result.Items[4].MediaItemId.Should().Be(2);
-            result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5));
-            result.Items[5].MediaItemId.Should().Be(4);
-
-            result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
-            result.Anchor.DurationFinish.Should().BeNull();
-        }
-
-        private static DateTimeOffset HoursAfterMidnight(int hours)
-        {
-            DateTimeOffset now = DateTimeOffset.Now;
-            return now - now.TimeOfDay + TimeSpan.FromHours(hours);
-        }
-
-        private static ProgramScheduleItem Flood(Collection mediaCollection, PlaybackOrder playbackOrder) =>
             new ProgramScheduleItemFlood
             {
                 Index = 1,
-                Collection = mediaCollection,
-                CollectionId = mediaCollection.Id,
+                Collection = floodCollection,
+                CollectionId = floodCollection.Id,
                 StartTime = null,
-                PlaybackOrder = playbackOrder
-            };
-
-        private static Movie TestMovie(int id, TimeSpan duration, DateTime aired) =>
-            new()
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemOne
             {
-                Id = id,
-                MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
-                MediaVersions = new List<MediaVersion>
-                {
-                    new() { Duration = duration }
-                }
-            };
+                Index = 2,
+                Collection = fixedCollection,
+                CollectionId = fixedCollection.Id,
+                StartTime = TimeSpan.FromHours(3),
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
 
-        private TestData TestDataFloodForItems(List<MediaItem> mediaItems, PlaybackOrder playbackOrder)
+        var playout = new Playout
         {
-            var mediaCollection = new Collection
+            ProgramSchedule = new ProgramSchedule
             {
-                Id = 1,
-                MediaItems = mediaItems
-            };
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
+        };
 
-            var configRepo = new Mock<IConfigElementRepository>();
-            var collectionRepo = new FakeMediaCollectionRepository(Map((mediaCollection.Id, mediaItems)));
-            var televisionRepo = new FakeTelevisionRepository();
-            var artistRepo = new Mock<IArtistRepository>();
-            var builder = new PlayoutBuilder(
-                configRepo.Object,
-                collectionRepo,
-                televisionRepo,
-                artistRepo.Object,
-                _logger);
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
 
-            var items = new List<ProgramScheduleItem> { Flood(mediaCollection, playbackOrder) };
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
 
-            var playout = new Playout
-            {
-                Id = 1,
-                ProgramSchedule = new ProgramSchedule { Items = items },
-                Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
-            };
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
 
-            return new TestData(builder, playout);
-        }
-
-        private record TestData(PlayoutBuilder Builder, Playout Playout);
+        result.Items.Count.Should().Be(5);
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[1].MediaItemId.Should().Be(2);
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[2].MediaItemId.Should().Be(1);
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+        result.Items[3].MediaItemId.Should().Be(3);
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5));
+        result.Items[4].MediaItemId.Should().Be(2);
     }
-}
+
+    [Test]
+    public async Task FloodContent_Should_FloodAroundFixedContent_Multiple()
+    {
+        var floodCollection = new Collection
+        {
+            Id = 1,
+            Name = "Flood Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
+            }
+        };
+
+        var fixedCollection = new Collection
+        {
+            Id = 2,
+            Name = "Fixed Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
+                TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 2))
+            }
+        };
+
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (floodCollection.Id, floodCollection.MediaItems.ToList()),
+                (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemFlood
+            {
+                Index = 1,
+                Collection = floodCollection,
+                CollectionId = floodCollection.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemMultiple
+            {
+                Index = 2,
+                Collection = fixedCollection,
+                CollectionId = fixedCollection.Id,
+                StartTime = TimeSpan.FromHours(3),
+                Count = 2,
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(7);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(6);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[1].MediaItemId.Should().Be(2);
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[2].MediaItemId.Should().Be(1);
+
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+        result.Items[3].MediaItemId.Should().Be(3);
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5));
+        result.Items[4].MediaItemId.Should().Be(4);
+
+        result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(6));
+        result.Items[5].MediaItemId.Should().Be(2);
+    }
+
+    [Test]
+    public async Task FloodContent_Should_FloodWithFixedStartTime()
+    {
+        var floodCollection = new Collection
+        {
+            Id = 1,
+            Name = "Flood Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
+            }
+        };
+
+        var fixedCollection = new Collection
+        {
+            Id = 2,
+            Name = "Fixed Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
+                TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 2))
+            }
+        };
+
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (floodCollection.Id, floodCollection.MediaItems.ToList()),
+                (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemFlood
+            {
+                Index = 1,
+                Collection = floodCollection,
+                CollectionId = floodCollection.Id,
+                StartTime = TimeSpan.FromHours(7),
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemOne
+            {
+                Index = 2,
+                Collection = fixedCollection,
+                CollectionId = fixedCollection.Id,
+                StartTime = TimeSpan.FromHours(12),
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(24);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(6);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(7));
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(8));
+        result.Items[1].MediaItemId.Should().Be(2);
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(9));
+        result.Items[2].MediaItemId.Should().Be(1);
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(10));
+        result.Items[3].MediaItemId.Should().Be(2);
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(11));
+        result.Items[4].MediaItemId.Should().Be(1);
+
+        result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(12));
+        result.Items[5].MediaItemId.Should().Be(3);
+    }
+
+    [Test]
+    public async Task FloodContent_Should_FloodWithFixedStartTime_FromAnchor()
+    {
+        var floodCollection = new Collection
+        {
+            Id = 1,
+            Name = "Flood Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
+            }
+        };
+
+        var fixedCollection = new Collection
+        {
+            Id = 2,
+            Name = "Fixed Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
+                TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 2))
+            }
+        };
+
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (floodCollection.Id, floodCollection.MediaItems.ToList()),
+                (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemFlood
+            {
+                Index = 1,
+                Collection = floodCollection,
+                CollectionId = floodCollection.Id,
+                StartTime = TimeSpan.FromHours(7),
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemOne
+            {
+                Index = 2,
+                Collection = fixedCollection,
+                CollectionId = fixedCollection.Id,
+                StartTime = TimeSpan.FromHours(12),
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+            Anchor = new PlayoutAnchor
+            {
+                NextStart = HoursAfterMidnight(9).UtcDateTime,
+                ScheduleItemsEnumeratorState = new CollectionEnumeratorState
+                {
+                    Index = 0,
+                    Seed = 1
+                },
+                InFlood = true
+            }
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(32);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(5);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(9));
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(10));
+        result.Items[1].MediaItemId.Should().Be(2);
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(11));
+        result.Items[2].MediaItemId.Should().Be(1);
+
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(12));
+        result.Items[3].MediaItemId.Should().Be(3);
+
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(7));
+        result.Items[4].MediaItemId.Should().Be(2);
+
+        result.Anchor.InFlood.Should().BeTrue();
+    }
+
+    [Test]
+    public async Task FloodContent_Should_FloodAroundFixedContent_DurationWithoutOfflineTail()
+    {
+        var floodCollection = new Collection
+        {
+            Id = 1,
+            Name = "Flood Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
+            }
+        };
+
+        var fixedCollection = new Collection
+        {
+            Id = 2,
+            Name = "Fixed Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(3, TimeSpan.FromHours(0.75), new DateTime(2020, 1, 1)),
+                TestMovie(4, TimeSpan.FromHours(1.5), new DateTime(2020, 1, 2))
+            }
+        };
+
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (floodCollection.Id, floodCollection.MediaItems.ToList()),
+                (fixedCollection.Id, fixedCollection.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemFlood
+            {
+                Index = 1,
+                Collection = floodCollection,
+                CollectionId = floodCollection.Id,
+                StartTime = null,
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemDuration
+            {
+                Index = 2,
+                Collection = fixedCollection,
+                CollectionId = fixedCollection.Id,
+                StartTime = TimeSpan.FromHours(2),
+                PlayoutDuration = TimeSpan.FromHours(2),
+                TailMode = TailMode.None, // immediately continue
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(7);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[1].MediaItemId.Should().Be(2);
+
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[2].MediaItemId.Should().Be(3);
+
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2.75));
+        result.Items[3].MediaItemId.Should().Be(1);
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3.75));
+        result.Items[4].MediaItemId.Should().Be(2);
+
+        result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4.75));
+        result.Items[5].MediaItemId.Should().Be(1);
+        result.Items[6].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5.75));
+        result.Items[6].MediaItemId.Should().Be(2);
+    }
+
+    [Test]
+    public async Task MultipleContent_Should_WrapAroundDynamicContent_DurationWithoutOfflineTail()
+    {
+        var multipleCollection = new Collection
+        {
+            Id = 1,
+            Name = "Multiple Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 2, 1))
+            }
+        };
+
+        var dynamicCollection = new Collection
+        {
+            Id = 2,
+            Name = "Dynamic Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(3, TimeSpan.FromHours(0.75), new DateTime(2020, 1, 1)),
+                TestMovie(4, TimeSpan.FromHours(1.5), new DateTime(2020, 1, 2))
+            }
+        };
+
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (multipleCollection.Id, multipleCollection.MediaItems.ToList()),
+                (dynamicCollection.Id, dynamicCollection.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemMultiple
+            {
+                Index = 1,
+                Collection = multipleCollection,
+                CollectionId = multipleCollection.Id,
+                StartTime = null,
+                Count = 2,
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemDuration
+            {
+                Index = 2,
+                Collection = dynamicCollection,
+                CollectionId = dynamicCollection.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(2),
+                TailMode = TailMode.None, // immediately continue
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(6);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.Zero);
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[1].MediaItemId.Should().Be(2);
+
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[2].MediaItemId.Should().Be(3);
+
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2.75));
+        result.Items[3].MediaItemId.Should().Be(1);
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3.75));
+        result.Items[4].MediaItemId.Should().Be(2);
+
+        result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4.75));
+        result.Items[5].MediaItemId.Should().Be(4);
+    }
+
+    [Test]
+    public async Task Alternating_MultipleContent_Should_Maintain_Counts()
+    {
+        var collectionOne = new Collection
+        {
+            Id = 1,
+            Name = "Multiple Items 1",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+            }
+        };
+
+        var collectionTwo = new Collection
+        {
+            Id = 2,
+            Name = "Multiple Items 2",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+            }
+        };
+
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (collectionOne.Id, collectionOne.MediaItems.ToList()),
+                (collectionTwo.Id, collectionTwo.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                Count = 3,
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemMultiple
+            {
+                Id = 2,
+                Index = 2,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id,
+                StartTime = null,
+                Count = 3,
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+            Anchor = new PlayoutAnchor
+            {
+                NextStart = HoursAfterMidnight(1).UtcDateTime,
+                ScheduleItemsEnumeratorState = new CollectionEnumeratorState
+                {
+                    Index = 0,
+                    Seed = 1
+                },
+                MultipleRemaining = 2
+            }
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(5);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(4);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[1].MediaItemId.Should().Be(1);
+
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+        result.Items[2].MediaItemId.Should().Be(2);
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
+        result.Items[3].MediaItemId.Should().Be(2);
+
+        result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(1);
+        result.Anchor.MultipleRemaining.Should().Be(1);
+    }
+
+    [Test]
+    public async Task Auto_Zero_MultipleCount()
+    {
+        var collectionOne = new Collection
+        {
+            Id = 1,
+            Name = "Multiple Items 1",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(3, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+            }
+        };
+
+        var collectionTwo = new Collection
+        {
+            Id = 2,
+            Name = "Multiple Items 2",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(5, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+            }
+        };
+
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (collectionOne.Id, collectionOne.MediaItems.ToList()),
+                (collectionTwo.Id, collectionTwo.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemMultiple
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                Count = 0,
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemMultiple
+            {
+                Id = 2,
+                Index = 2,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id,
+                StartTime = null,
+                Count = 0,
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(5);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(5);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(0));
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[1].MediaItemId.Should().Be(2);
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[2].MediaItemId.Should().Be(3);
+            
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+        result.Items[3].MediaItemId.Should().Be(4);
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
+        result.Items[4].MediaItemId.Should().Be(5);
+
+        result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
+        result.Anchor.MultipleRemaining.Should().BeNull();
+    }
+
+    [Test]
+    public async Task Alternating_Duration_Should_Maintain_Duration()
+    {
+        var collectionOne = new Collection
+        {
+            Id = 1,
+            Name = "Duration Items 1",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+            }
+        };
+
+        var collectionTwo = new Collection
+        {
+            Id = 2,
+            Name = "Duration Items 2",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+            }
+        };
+
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (collectionOne.Id, collectionOne.MediaItems.ToList()),
+                (collectionTwo.Id, collectionTwo.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.None,
+                PlaybackOrder = PlaybackOrder.Chronological
+            },
+            new ProgramScheduleItemDuration
+            {
+                Id = 2,
+                Index = 2,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                TailMode = TailMode.None,
+                PlaybackOrder = PlaybackOrder.Chronological
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+            Anchor = new PlayoutAnchor
+            {
+                NextStart = HoursAfterMidnight(1).UtcDateTime,
+                ScheduleItemsEnumeratorState = new CollectionEnumeratorState
+                {
+                    Index = 0,
+                    Seed = 1
+                },
+                DurationFinish = HoursAfterMidnight(3).UtcDateTime
+            }
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(5);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(4);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[1].MediaItemId.Should().Be(1);
+
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+        result.Items[2].MediaItemId.Should().Be(2);
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
+        result.Items[3].MediaItemId.Should().Be(2);
+
+        result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(1);
+        result.Anchor.DurationFinish.Should().Be(HoursAfterMidnight(6).UtcDateTime);
+    }
+        
+    [Test]
+    public async Task Alternating_Duration_With_Filler_Should_Alternate_Schedule_Items()
+    {
+        var collectionOne = new Collection
+        {
+            Id = 1,
+            Name = "Duration Items 1",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromMinutes(55), new DateTime(2020, 1, 1))
+            }
+        };
+            
+        var collectionTwo = new Collection
+        {
+            Id = 2,
+            Name = "Duration Items 2",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(2, TimeSpan.FromMinutes(55), new DateTime(2020, 1, 1))
+            }
+        };
+            
+        var collectionThree = new Collection
+        {
+            Id = 3,
+            Name = "Filler Items",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(3, TimeSpan.FromMinutes(5), new DateTime(2020, 1, 1))
+            }
+        };
+            
+        var fakeRepository = new FakeMediaCollectionRepository(
+            Map(
+                (collectionOne.Id, collectionOne.MediaItems.ToList()),
+                (collectionTwo.Id, collectionTwo.MediaItems.ToList()),
+                (collectionThree.Id, collectionThree.MediaItems.ToList())));
+            
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailMode = TailMode.Filler,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            },
+            new ProgramScheduleItemDuration
+            {
+                Id = 2,
+                Index = 2,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(3),
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailMode = TailMode.Filler,
+                TailFiller = new FillerPreset
+                {
+                    FillerKind = FillerKind.Tail,
+                    Collection = collectionThree,
+                    CollectionId = collectionThree.Id
+                }
+            }
+        };
+            
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+        };
+            
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+            
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
+            
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+            
+        result.Items.Count.Should().Be(12);
+            
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromMinutes(0));
+        result.Items[0].MediaItemId.Should().Be(1);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromMinutes(55));
+        result.Items[1].MediaItemId.Should().Be(1);
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(new TimeSpan(1, 50, 0));
+        result.Items[2].MediaItemId.Should().Be(1);
+            
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 45, 0));
+        result.Items[3].MediaItemId.Should().Be(3);
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 50, 0));
+        result.Items[4].MediaItemId.Should().Be(3);
+        result.Items[5].StartOffset.TimeOfDay.Should().Be(new TimeSpan(2, 55, 0));
+        result.Items[5].MediaItemId.Should().Be(3);
+            
+        result.Items[6].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+        result.Items[6].MediaItemId.Should().Be(2);
+        result.Items[7].StartOffset.TimeOfDay.Should().Be(new TimeSpan(3, 55, 0));
+        result.Items[7].MediaItemId.Should().Be(2);
+        result.Items[8].StartOffset.TimeOfDay.Should().Be(new TimeSpan(4, 50, 0));
+        result.Items[8].MediaItemId.Should().Be(2);
+            
+        result.Items[9].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 45, 0));
+        result.Items[9].MediaItemId.Should().Be(3);
+        result.Items[10].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 50, 0));
+        result.Items[10].MediaItemId.Should().Be(3);
+        result.Items[11].StartOffset.TimeOfDay.Should().Be(new TimeSpan(5, 55, 0));
+        result.Items[11].MediaItemId.Should().Be(3);
+            
+        result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
+        result.Anchor.DurationFinish.Should().BeNull();
+    }
+        
+    [Test]
+    public async Task Duration_Should_Skip_Items_That_Are_Too_Long()
+    {
+        var collectionOne = new Collection
+        {
+            Id = 1,
+            Name = "Duration Items 1",
+            MediaItems = new List<MediaItem>
+            {
+                TestMovie(1, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
+                TestMovie(2, TimeSpan.FromHours(1), new DateTime(2020, 1, 1)),
+                TestMovie(3, TimeSpan.FromHours(2), new DateTime(2020, 1, 1)),
+                TestMovie(4, TimeSpan.FromHours(1), new DateTime(2020, 1, 1))
+            }
+        };
+
+        var fakeRepository =
+            new FakeMediaCollectionRepository(Map((collectionOne.Id, collectionOne.MediaItems.ToList())));
+
+        var items = new List<ProgramScheduleItem>
+        {
+            new ProgramScheduleItemDuration
+            {
+                Id = 1,
+                Index = 1,
+                Collection = collectionOne,
+                CollectionId = collectionOne.Id,
+                StartTime = null,
+                PlayoutDuration = TimeSpan.FromHours(1),
+                PlaybackOrder = PlaybackOrder.Chronological,
+                TailMode = TailMode.None,
+            }
+        };
+
+        var playout = new Playout
+        {
+            ProgramSchedule = new ProgramSchedule
+            {
+                Items = items
+            },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" },
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            fakeRepository,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        DateTimeOffset start = HoursAfterMidnight(0);
+        DateTimeOffset finish = start + TimeSpan.FromHours(6);
+
+        Playout result = await builder.BuildPlayoutItems(playout, start, finish);
+
+        result.Items.Count.Should().Be(6);
+
+        result.Items[0].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(0));
+        result.Items[0].MediaItemId.Should().Be(2);
+        result.Items[1].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(1));
+        result.Items[1].MediaItemId.Should().Be(4);
+        result.Items[2].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(2));
+        result.Items[2].MediaItemId.Should().Be(2);
+        result.Items[3].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(3));
+        result.Items[3].MediaItemId.Should().Be(4);
+        result.Items[4].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(4));
+        result.Items[4].MediaItemId.Should().Be(2);
+        result.Items[5].StartOffset.TimeOfDay.Should().Be(TimeSpan.FromHours(5));
+        result.Items[5].MediaItemId.Should().Be(4);
+
+        result.Anchor.ScheduleItemsEnumeratorState.Index.Should().Be(0);
+        result.Anchor.DurationFinish.Should().BeNull();
+    }
+
+    private static DateTimeOffset HoursAfterMidnight(int hours)
+    {
+        DateTimeOffset now = DateTimeOffset.Now;
+        return now - now.TimeOfDay + TimeSpan.FromHours(hours);
+    }
+
+    private static ProgramScheduleItem Flood(Collection mediaCollection, PlaybackOrder playbackOrder) =>
+        new ProgramScheduleItemFlood
+        {
+            Index = 1,
+            Collection = mediaCollection,
+            CollectionId = mediaCollection.Id,
+            StartTime = null,
+            PlaybackOrder = playbackOrder
+        };
+
+    private static Movie TestMovie(int id, TimeSpan duration, DateTime aired) =>
+        new()
+        {
+            Id = id,
+            MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
+            MediaVersions = new List<MediaVersion>
+            {
+                new() { Duration = duration }
+            }
+        };
+
+    private TestData TestDataFloodForItems(List<MediaItem> mediaItems, PlaybackOrder playbackOrder)
+    {
+        var mediaCollection = new Collection
+        {
+            Id = 1,
+            MediaItems = mediaItems
+        };
+
+        var configRepo = new Mock<IConfigElementRepository>();
+        var collectionRepo = new FakeMediaCollectionRepository(Map((mediaCollection.Id, mediaItems)));
+        var televisionRepo = new FakeTelevisionRepository();
+        var artistRepo = new Mock<IArtistRepository>();
+        var builder = new PlayoutBuilder(
+            configRepo.Object,
+            collectionRepo,
+            televisionRepo,
+            artistRepo.Object,
+            _logger);
+
+        var items = new List<ProgramScheduleItem> { Flood(mediaCollection, playbackOrder) };
+
+        var playout = new Playout
+        {
+            Id = 1,
+            ProgramSchedule = new ProgramSchedule { Items = items },
+            Channel = new Channel(Guid.Empty) { Id = 1, Name = "Test Channel" }
+        };
+
+        return new TestData(builder, playout);
+    }
+
+    private record TestData(PlayoutBuilder Builder, Playout Playout);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerBaseTests.cs b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerBaseTests.cs
index 6022096db..443cdb1ae 100644
--- a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerBaseTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerBaseTests.cs
@@ -1,205 +1,202 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class PlayoutModeSchedulerBaseTests
 {
-    [TestFixture]
-    public class PlayoutModeSchedulerBaseTests
+    [Test]
+    public void CalculateEndTimeWithFiller_Should_Not_Touch_Enumerator()
     {
-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Not_Touch_Enumerator()
+        var collection = new Collection
         {
-            var collection = new Collection
-            {
-                Id = 1,
-                Name = "Filler Items",
-                MediaItems = new List<MediaItem>()
-            };
+            Id = 1,
+            Name = "Filler Items",
+            MediaItems = new List<MediaItem>()
+        };
 
-            for (var i = 0; i < 5; i++)
-            {
-                collection.MediaItems.Add(TestMovie(i + 1, TimeSpan.FromHours(i + 1), new DateTime(2020, 2, i + 1)));
-            }
-
-            var fillerPreset = new FillerPreset
-            {
-                FillerKind = FillerKind.PreRoll,
-                FillerMode = FillerMode.Count,
-                Count = 3,
-                Collection = collection,
-                CollectionId = collection.Id
-            };
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collection.MediaItems,
-                new CollectionEnumeratorState { Index = 0, Seed = 1 });
-
-            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
-                .CalculateEndTimeWithFiller(
-                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>
-                    {
-                        { CollectionKey.ForFillerPreset(fillerPreset), enumerator }
-                    },
-                    new ProgramScheduleItemOne
-                    {
-                        PreRollFiller = fillerPreset
-                    },
-                    new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
-                    new TimeSpan(0, 12, 30),
-                    new List<MediaChapter>());
-
-            result.Should().Be(new DateTimeOffset(2020, 2, 1, 18, 12, 30, TimeSpan.FromHours(-5)));
-            enumerator.State.Index.Should().Be(0);
-            enumerator.State.Seed.Should().Be(1);
+        for (var i = 0; i < 5; i++)
+        {
+            collection.MediaItems.Add(TestMovie(i + 1, TimeSpan.FromHours(i + 1), new DateTime(2020, 2, i + 1)));
         }
 
-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_15()
+        var fillerPreset = new FillerPreset
         {
-            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
-                .CalculateEndTimeWithFiller(
-                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
-                    new ProgramScheduleItemOne
-                    {
-                        MidRollFiller = new FillerPreset
-                        {
-                            FillerKind = FillerKind.MidRoll,
-                            FillerMode = FillerMode.Pad,
-                            PadToNearestMinute = 15
-                        }
-                    },
-                    new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
-                    new TimeSpan(0, 12, 30),
-                    new List<MediaChapter>());
+            FillerKind = FillerKind.PreRoll,
+            FillerMode = FillerMode.Count,
+            Count = 3,
+            Collection = collection,
+            CollectionId = collection.Id
+        };
 
-            result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 15, 0, TimeSpan.FromHours(-5)));
-        }
-        
-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_30()
-        {
-            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
-                .CalculateEndTimeWithFiller(
-                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
-                    new ProgramScheduleItemOne
-                    {
-                        MidRollFiller = new FillerPreset
-                        {
-                            FillerKind = FillerKind.MidRoll,
-                            FillerMode = FillerMode.Pad,
-                            PadToNearestMinute = 15
-                        }
-                    },
-                    new DateTimeOffset(2020, 2, 1, 12, 16, 0, TimeSpan.FromHours(-5)),
-                    new TimeSpan(0, 12, 30),
-                    new List<MediaChapter>());
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collection.MediaItems,
+            new CollectionEnumeratorState { Index = 0, Seed = 1 });
 
-            result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)));
-        }
-        
-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_45()
-        {
-            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
-                .CalculateEndTimeWithFiller(
-                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
-                    new ProgramScheduleItemOne
-                    {
-                        MidRollFiller = new FillerPreset
-                        {
-                            FillerKind = FillerKind.MidRoll,
-                            FillerMode = FillerMode.Pad,
-                            PadToNearestMinute = 15
-                        }
-                    },
-                    new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)),
-                    new TimeSpan(0, 12, 30),
-                    new List<MediaChapter>());
-
-            result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 45, 0, TimeSpan.FromHours(-5)));
-        }
-        
-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_00()
-        {
-            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
-                .CalculateEndTimeWithFiller(
-                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
-                    new ProgramScheduleItemOne
-                    {
-                        MidRollFiller = new FillerPreset
-                        {
-                            FillerKind = FillerKind.MidRoll,
-                            FillerMode = FillerMode.Pad,
-                            PadToNearestMinute = 15
-                        }
-                    },
-                    new DateTimeOffset(2020, 2, 1, 12, 46, 0, TimeSpan.FromHours(-5)),
-                    new TimeSpan(0, 12, 30),
-                    new List<MediaChapter>());
-
-            result.Should().Be(new DateTimeOffset(2020, 2, 1, 13, 0, 0, TimeSpan.FromHours(-5)));
-        }
-        
-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Pad_To_30_Minutes_30()
-        {
-            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
-                .CalculateEndTimeWithFiller(
-                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
-                    new ProgramScheduleItemOne
-                    {
-                        MidRollFiller = new FillerPreset
-                        {
-                            FillerKind = FillerKind.MidRoll,
-                            FillerMode = FillerMode.Pad,
-                            PadToNearestMinute = 30
-                        }
-                    },
-                    new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
-                    new TimeSpan(0, 12, 30),
-                    new List<MediaChapter>());
-
-            result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)));
-        }
-        
-        [Test]
-        public void CalculateEndTimeWithFiller_Should_Pad_To_30_Minutes_00()
-        {
-            DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
-                .CalculateEndTimeWithFiller(
-                    new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
-                    new ProgramScheduleItemOne
-                    {
-                        MidRollFiller = new FillerPreset
-                        {
-                            FillerKind = FillerKind.MidRoll,
-                            FillerMode = FillerMode.Pad,
-                            PadToNearestMinute = 30
-                        }
-                    },
-                    new DateTimeOffset(2020, 2, 1, 12, 20, 0, TimeSpan.FromHours(-5)),
-                    new TimeSpan(0, 12, 30),
-                    new List<MediaChapter>());
-
-            result.Should().Be(new DateTimeOffset(2020, 2, 1, 13, 0, 0, TimeSpan.FromHours(-5)));
-        }
-
-        private static Movie TestMovie(int id, TimeSpan duration, DateTime aired) =>
-            new()
-            {
-                Id = id,
-                MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
-                MediaVersions = new List<MediaVersion>
+        DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            .CalculateEndTimeWithFiller(
+                new Dictionary<CollectionKey, IMediaCollectionEnumerator>
                 {
-                    new() { Duration = duration }
-                }
-            };
+                    { CollectionKey.ForFillerPreset(fillerPreset), enumerator }
+                },
+                new ProgramScheduleItemOne
+                {
+                    PreRollFiller = fillerPreset
+                },
+                new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
+                new TimeSpan(0, 12, 30),
+                new List<MediaChapter>());
+
+        result.Should().Be(new DateTimeOffset(2020, 2, 1, 18, 12, 30, TimeSpan.FromHours(-5)));
+        enumerator.State.Index.Should().Be(0);
+        enumerator.State.Seed.Should().Be(1);
     }
-}
+
+    [Test]
+    public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_15()
+    {
+        DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            .CalculateEndTimeWithFiller(
+                new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                new ProgramScheduleItemOne
+                {
+                    MidRollFiller = new FillerPreset
+                    {
+                        FillerKind = FillerKind.MidRoll,
+                        FillerMode = FillerMode.Pad,
+                        PadToNearestMinute = 15
+                    }
+                },
+                new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
+                new TimeSpan(0, 12, 30),
+                new List<MediaChapter>());
+
+        result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 15, 0, TimeSpan.FromHours(-5)));
+    }
+        
+    [Test]
+    public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_30()
+    {
+        DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            .CalculateEndTimeWithFiller(
+                new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                new ProgramScheduleItemOne
+                {
+                    MidRollFiller = new FillerPreset
+                    {
+                        FillerKind = FillerKind.MidRoll,
+                        FillerMode = FillerMode.Pad,
+                        PadToNearestMinute = 15
+                    }
+                },
+                new DateTimeOffset(2020, 2, 1, 12, 16, 0, TimeSpan.FromHours(-5)),
+                new TimeSpan(0, 12, 30),
+                new List<MediaChapter>());
+
+        result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)));
+    }
+        
+    [Test]
+    public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_45()
+    {
+        DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            .CalculateEndTimeWithFiller(
+                new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                new ProgramScheduleItemOne
+                {
+                    MidRollFiller = new FillerPreset
+                    {
+                        FillerKind = FillerKind.MidRoll,
+                        FillerMode = FillerMode.Pad,
+                        PadToNearestMinute = 15
+                    }
+                },
+                new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)),
+                new TimeSpan(0, 12, 30),
+                new List<MediaChapter>());
+
+        result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 45, 0, TimeSpan.FromHours(-5)));
+    }
+        
+    [Test]
+    public void CalculateEndTimeWithFiller_Should_Pad_To_15_Minutes_00()
+    {
+        DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            .CalculateEndTimeWithFiller(
+                new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                new ProgramScheduleItemOne
+                {
+                    MidRollFiller = new FillerPreset
+                    {
+                        FillerKind = FillerKind.MidRoll,
+                        FillerMode = FillerMode.Pad,
+                        PadToNearestMinute = 15
+                    }
+                },
+                new DateTimeOffset(2020, 2, 1, 12, 46, 0, TimeSpan.FromHours(-5)),
+                new TimeSpan(0, 12, 30),
+                new List<MediaChapter>());
+
+        result.Should().Be(new DateTimeOffset(2020, 2, 1, 13, 0, 0, TimeSpan.FromHours(-5)));
+    }
+        
+    [Test]
+    public void CalculateEndTimeWithFiller_Should_Pad_To_30_Minutes_30()
+    {
+        DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            .CalculateEndTimeWithFiller(
+                new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                new ProgramScheduleItemOne
+                {
+                    MidRollFiller = new FillerPreset
+                    {
+                        FillerKind = FillerKind.MidRoll,
+                        FillerMode = FillerMode.Pad,
+                        PadToNearestMinute = 30
+                    }
+                },
+                new DateTimeOffset(2020, 2, 1, 12, 0, 0, TimeSpan.FromHours(-5)),
+                new TimeSpan(0, 12, 30),
+                new List<MediaChapter>());
+
+        result.Should().Be(new DateTimeOffset(2020, 2, 1, 12, 30, 0, TimeSpan.FromHours(-5)));
+    }
+        
+    [Test]
+    public void CalculateEndTimeWithFiller_Should_Pad_To_30_Minutes_00()
+    {
+        DateTimeOffset result = PlayoutModeSchedulerBase<ProgramScheduleItem>
+            .CalculateEndTimeWithFiller(
+                new Dictionary<CollectionKey, IMediaCollectionEnumerator>(),
+                new ProgramScheduleItemOne
+                {
+                    MidRollFiller = new FillerPreset
+                    {
+                        FillerKind = FillerKind.MidRoll,
+                        FillerMode = FillerMode.Pad,
+                        PadToNearestMinute = 30
+                    }
+                },
+                new DateTimeOffset(2020, 2, 1, 12, 20, 0, TimeSpan.FromHours(-5)),
+                new TimeSpan(0, 12, 30),
+                new List<MediaChapter>());
+
+        result.Should().Be(new DateTimeOffset(2020, 2, 1, 13, 0, 0, TimeSpan.FromHours(-5)));
+    }
+
+    private static Movie TestMovie(int id, TimeSpan duration, DateTime aired) =>
+        new()
+        {
+            Id = id,
+            MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
+            MediaVersions = new List<MediaVersion>
+            {
+                new() { Duration = duration }
+            }
+        };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerDurationTests.cs b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerDurationTests.cs
index 0b9e91db8..f8868b5eb 100644
--- a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerDurationTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerDurationTests.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
@@ -9,690 +6,689 @@ using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class PlayoutModeSchedulerDurationTests : SchedulerTestBase
 {
-    [TestFixture]
-    public class PlayoutModeSchedulerDurationTests : SchedulerTestBase
+    [Test]
+    public void Should_Fill_Exact_Duration()
     {
-        [Test]
-        public void Should_Fill_Exact_Duration()
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+        var scheduleItem = new ProgramScheduleItemDuration
         {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlayoutDuration = TimeSpan.FromHours(3),
+            TailMode = TailMode.None,
+            PlaybackOrder = PlaybackOrder.Chronological
+        };
 
-            var scheduleItem = new ProgramScheduleItemDuration
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlayoutDuration = TimeSpan.FromHours(3),
-                TailMode = TailMode.None,
-                PlaybackOrder = PlaybackOrder.Chronological
-            };
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
 
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
 
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
             
-            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
-        }
-        
-        [Test]
-        public void Should_Fill_Exact_Duration_CustomTitle()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-
-            var scheduleItem = new ProgramScheduleItemDuration
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlayoutDuration = TimeSpan.FromHours(3),
-                TailMode = TailMode.None,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                CustomTitle = "Custom Title"
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
-            playoutItems[0].CustomTitle.Should().Be("Custom Title");
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[1].GuideGroup.Should().Be(1);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
-            playoutItems[1].CustomTitle.Should().Be("Custom Title");
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
-            playoutItems[2].GuideGroup.Should().Be(1);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
-            playoutItems[2].CustomTitle.Should().Be("Custom Title");
-        }
-        
-        [Test]
-        public void Should_Not_Have_Gap_Duration_Tail_Mode_None()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-
-            var scheduleItem = new ProgramScheduleItemDuration
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlayoutDuration = TimeSpan.FromHours(3),
-                TailMode = TailMode.None,
-                PlaybackOrder = PlaybackOrder.Chronological
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-            
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
-        }
-        
-        [Test]
-        public void Should_Have_Gap_Duration_Tail_Mode_Offline_No_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-
-            var scheduleItem = new ProgramScheduleItemDuration
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlayoutDuration = TimeSpan.FromHours(3),
-                TailMode = TailMode.Offline,
-                PlaybackOrder = PlaybackOrder.Chronological
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            // duration block should end after exact duration, with gap
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-            
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
-        }
-        
-        [Test]
-        public void Should_Not_Have_Gap_Duration_Tail_Mode_Offline_With_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemDuration
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlayoutDuration = TimeSpan.FromHours(3),
-                TailMode = TailMode.Offline,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-            
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-            
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(4);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
-            
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
-            playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_Duration_Tail_Mode_Filler_Exact_Duration()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-
-            var scheduleItem = new ProgramScheduleItemDuration
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlayoutDuration = TimeSpan.FromHours(3),
-                TailMode = TailMode.Filler,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-            
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(6);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
-        }
-        
-        [Test]
-        public void Should_Have_Gap_Duration_Tail_Mode_Filler_No_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-
-            var scheduleItem = new ProgramScheduleItemDuration
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlayoutDuration = TimeSpan.FromHours(3),
-                TailMode = TailMode.Filler,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-            
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(6);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[4].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[5].GuideFinish.HasValue.Should().BeFalse();
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_Duration_Tail_Mode_Filler_With_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemDuration
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlayoutDuration = TimeSpan.FromHours(3),
-                TailMode = TailMode.Filler,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(
-                    scheduleItem,
-                    enumerator1,
-                    scheduleItem.TailFiller,
-                    enumerator2,
-                    scheduleItem.FallbackFiller,
-                    enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-            
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-            enumerator3.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(7);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[4].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-            playoutItems[5].GuideFinish.HasValue.Should().BeFalse();
-
-            playoutItems[6].MediaItemId.Should().Be(5);
-            playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
-            playoutItems[6].GuideGroup.Should().Be(3);
-            playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
-            playoutItems[6].GuideFinish.HasValue.Should().BeFalse();
-        }
+        var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
     }
-}
+        
+    [Test]
+    public void Should_Fill_Exact_Duration_CustomTitle()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+        var scheduleItem = new ProgramScheduleItemDuration
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlayoutDuration = TimeSpan.FromHours(3),
+            TailMode = TailMode.None,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            CustomTitle = "Custom Title"
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+        playoutItems[0].CustomTitle.Should().Be("Custom Title");
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[1].GuideGroup.Should().Be(1);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+        playoutItems[1].CustomTitle.Should().Be("Custom Title");
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
+        playoutItems[2].GuideGroup.Should().Be(1);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
+        playoutItems[2].CustomTitle.Should().Be("Custom Title");
+    }
+        
+    [Test]
+    public void Should_Not_Have_Gap_Duration_Tail_Mode_None()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+
+        var scheduleItem = new ProgramScheduleItemDuration
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlayoutDuration = TimeSpan.FromHours(3),
+            TailMode = TailMode.None,
+            PlaybackOrder = PlaybackOrder.Chronological
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+            
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
+    }
+        
+    [Test]
+    public void Should_Have_Gap_Duration_Tail_Mode_Offline_No_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+
+        var scheduleItem = new ProgramScheduleItemDuration
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlayoutDuration = TimeSpan.FromHours(3),
+            TailMode = TailMode.Offline,
+            PlaybackOrder = PlaybackOrder.Chronological
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        // duration block should end after exact duration, with gap
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+            
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
+    }
+        
+    [Test]
+    public void Should_Not_Have_Gap_Duration_Tail_Mode_Offline_With_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemDuration
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlayoutDuration = TimeSpan.FromHours(3),
+            TailMode = TailMode.Offline,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+            
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+            
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(4);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
+            
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
+        playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_Duration_Tail_Mode_Filler_Exact_Duration()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+        var scheduleItem = new ProgramScheduleItemDuration
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlayoutDuration = TimeSpan.FromHours(3),
+            TailMode = TailMode.Filler,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+            
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(6);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
+    }
+        
+    [Test]
+    public void Should_Have_Gap_Duration_Tail_Mode_Filler_No_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+
+        var scheduleItem = new ProgramScheduleItemDuration
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlayoutDuration = TimeSpan.FromHours(3),
+            TailMode = TailMode.Filler,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+            
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(6);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[4].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[5].GuideFinish.HasValue.Should().BeFalse();
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_Duration_Tail_Mode_Filler_With_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemDuration
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlayoutDuration = TimeSpan.FromHours(3),
+            TailMode = TailMode.Filler,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerDuration(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(
+                scheduleItem,
+                enumerator1,
+                scheduleItem.TailFiller,
+                enumerator2,
+                scheduleItem.FallbackFiller,
+                enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+            
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+        enumerator3.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(7);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[0].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[1].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+        playoutItems[2].GuideFinish.HasValue.Should().BeTrue();
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[3].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[4].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+        playoutItems[5].GuideFinish.HasValue.Should().BeFalse();
+
+        playoutItems[6].MediaItemId.Should().Be(5);
+        playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+        playoutItems[6].GuideGroup.Should().Be(3);
+        playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
+        playoutItems[6].GuideFinish.HasValue.Should().BeFalse();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerFloodTests.cs b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerFloodTests.cs
index ca9745c61..70b636673 100644
--- a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerFloodTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerFloodTests.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
@@ -9,830 +6,829 @@ using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class PlayoutModeSchedulerFloodTests : SchedulerTestBase
 {
-    [TestFixture]
-    public class PlayoutModeSchedulerFloodTests : SchedulerTestBase
+    [Test]
+    public void Should_Fill_Exactly_To_Next_Schedule_Item()
     {
-        [Test]
-        public void Should_Fill_Exactly_To_Next_Schedule_Item()
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+        var scheduleItem = new ProgramScheduleItemFlood
         {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = null
-            };
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                NextScheduleItem
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-        }
-        
-        [Test]
-        public void Should_Fill_Exactly_To_Next_Schedule_Item_Flood()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = null
-            };
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                // this caused trouble with the peek logic and the IsFlood flag
-                new ProgramScheduleItemFlood
-                {
-                    StartTime = TimeSpan.FromHours(3),
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-        }
-        
-        [Test]
-        public void Should_Fill_Exactly_To_Next_Schedule_Item_With_Post_Roll_Multiple_One()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                PostRollFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.PostRoll,
-                    FillerMode = FillerMode.Count,
-                    Count = 1,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                TailFiller = null,
-                FallbackFiller = null
-            };
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                NextScheduleItem
-            };
-
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(6);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(1);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
-
-            playoutItems[2].MediaItemId.Should().Be(2);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[2].GuideGroup.Should().Be(2);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[3].MediaItemId.Should().Be(4);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 55, 0)));
-            playoutItems[3].GuideGroup.Should().Be(2);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
-
-            playoutItems[4].MediaItemId.Should().Be(1);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.PostRoll);
-        }
-
-        [Test]
-        public void Should_Have_Gap_With_No_Tail_No_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = null
-            };
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                NextScheduleItem
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Exact_Tail()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = null
-            };
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                NextScheduleItem
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(6);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                }
-            };
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                NextScheduleItem
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(4);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
-        }
-        
-        [Test]
-        public void Should_Have_Gap_With_Tail_No_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = null
-            };
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                NextScheduleItem
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(6);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Tail_And_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                }
-            };
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                NextScheduleItem
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(
-                    scheduleItem,
-                    enumerator1,
-                    scheduleItem.TailFiller,
-                    enumerator2,
-                    scheduleItem.FallbackFiller,
-                    enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-            enumerator3.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(7);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[6].MediaItemId.Should().Be(5);
-            playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
-            playoutItems[6].GuideGroup.Should().Be(3);
-            playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemFlood
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                }
-            };
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-
-            var sortedScheduleItems = new List<ProgramScheduleItem>
-            {
-                scheduleItem,
-                NextScheduleItem
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                sortedScheduleItems,
-                new CollectionEnumeratorState());
-
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(
-                    scheduleItem,
-                    enumerator1,
-                    scheduleItem.TailFiller,
-                    enumerator2,
-                    scheduleItem.FallbackFiller,
-                    enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(0);
-            enumerator3.State.Index.Should().Be(0);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-        }
-
-        protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
-        {
-            StartTime = TimeSpan.FromHours(3),
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = null
         };
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            NextScheduleItem
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
     }
-}
+        
+    [Test]
+    public void Should_Fill_Exactly_To_Next_Schedule_Item_Flood()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+        var scheduleItem = new ProgramScheduleItemFlood
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = null
+        };
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            // this caused trouble with the peek logic and the IsFlood flag
+            new ProgramScheduleItemFlood
+            {
+                StartTime = TimeSpan.FromHours(3),
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+    }
+        
+    [Test]
+    public void Should_Fill_Exactly_To_Next_Schedule_Item_With_Post_Roll_Multiple_One()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+        var scheduleItem = new ProgramScheduleItemFlood
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            PostRollFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.PostRoll,
+                FillerMode = FillerMode.Count,
+                Count = 1,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            TailFiller = null,
+            FallbackFiller = null
+        };
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            NextScheduleItem
+        };
+
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(6);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(3);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(1);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
+
+        playoutItems[2].MediaItemId.Should().Be(2);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[2].GuideGroup.Should().Be(2);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[3].MediaItemId.Should().Be(4);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 55, 0)));
+        playoutItems[3].GuideGroup.Should().Be(2);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
+
+        playoutItems[4].MediaItemId.Should().Be(1);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.PostRoll);
+    }
+
+    [Test]
+    public void Should_Have_Gap_With_No_Tail_No_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+
+        var scheduleItem = new ProgramScheduleItemFlood
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = null
+        };
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            NextScheduleItem
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Exact_Tail()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+        var scheduleItem = new ProgramScheduleItemFlood
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = null
+        };
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            NextScheduleItem
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(6);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+        var scheduleItem = new ProgramScheduleItemFlood
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            }
+        };
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            NextScheduleItem
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(4);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
+    }
+        
+    [Test]
+    public void Should_Have_Gap_With_Tail_No_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+
+        var scheduleItem = new ProgramScheduleItemFlood
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = null
+        };
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            NextScheduleItem
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(6);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Tail_And_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemFlood
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            }
+        };
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            NextScheduleItem
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(
+                scheduleItem,
+                enumerator1,
+                scheduleItem.TailFiller,
+                enumerator2,
+                scheduleItem.FallbackFiller,
+                enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+        enumerator3.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(7);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[6].MediaItemId.Should().Be(5);
+        playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+        playoutItems[6].GuideGroup.Should().Be(3);
+        playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemFlood
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            }
+        };
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+
+        var sortedScheduleItems = new List<ProgramScheduleItem>
+        {
+            scheduleItem,
+            NextScheduleItem
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            sortedScheduleItems,
+            new CollectionEnumeratorState());
+
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerFlood(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(
+                scheduleItem,
+                enumerator1,
+                scheduleItem.TailFiller,
+                enumerator2,
+                scheduleItem.FallbackFiller,
+                enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(1);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(0);
+        enumerator3.State.Index.Should().Be(0);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+    }
+
+    protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+    {
+        StartTime = TimeSpan.FromHours(3),
+    };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerMultipleTests.cs b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerMultipleTests.cs
index 28bc07201..bfe37da57 100644
--- a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerMultipleTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerMultipleTests.cs
@@ -1,672 +1,667 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class PlayoutModeSchedulerMultipleTests : SchedulerTestBase
 {
-    [TestFixture]
-    public class PlayoutModeSchedulerMultipleTests : SchedulerTestBase
+    [Test]
+    public void Should_Fill_Exactly_To_Next_Schedule_Item()
     {
-        [Test]
-        public void Should_Fill_Exactly_To_Next_Schedule_Item()
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+        var scheduleItem = new ProgramScheduleItemMultiple
         {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-
-            var scheduleItem = new ProgramScheduleItemMultiple
-            {
-                Id = 1,
-                Index = 1,
-                CollectionType = ProgramScheduleItemCollectionType.Collection,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = null,
-                Count = 3
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems }
-            }.ToMap();
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-        }
-
-        [Test]
-        public void Should_Have_Gap_With_No_Tail_No_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-
-            var scheduleItem = new ProgramScheduleItemMultiple
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = null,
-                Count = 3
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems }
-            }.ToMap();
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Exact_Tail()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-
-            var scheduleItem = new ProgramScheduleItemMultiple
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = null,
-                Count = 3
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
-                { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems }
-            }.ToMap();
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(6);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-
-            var scheduleItem = new ProgramScheduleItemMultiple
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                Count = 3
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
-                { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionTwo.MediaItems }
-            }.ToMap();
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(4);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
-        }
-        
-        [Test]
-        public void Should_Have_Gap_With_Tail_No_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-
-            var scheduleItem = new ProgramScheduleItemMultiple
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = null,
-                Count = 3
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
-                { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems }
-            }.ToMap();
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(6);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-            
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-        
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Tail_And_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemMultiple
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                },
-                Count = 3
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-
-            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
-                { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems },
-                { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionThree.MediaItems }
-            }.ToMap();
-
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(
-                    scheduleItem,
-                    enumerator1,
-                    scheduleItem.TailFiller,
-                    enumerator2,
-                    scheduleItem.FallbackFiller,
-                    enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-            enumerator3.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(7);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-        
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-            
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[3].GuideGroup.Should().Be(3);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[4].MediaItemId.Should().Be(4);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
-            playoutItems[4].GuideGroup.Should().Be(3);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
-        
-            playoutItems[5].MediaItemId.Should().Be(3);
-            playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
-            playoutItems[5].GuideGroup.Should().Be(3);
-            playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[6].MediaItemId.Should().Be(5);
-            playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
-            playoutItems[6].GuideGroup.Should().Be(3);
-            playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemMultiple
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                },
-                Count = 3
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-
-            var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
-                { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems },
-                { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionThree.MediaItems }
-            }.ToMap();
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(
-                    scheduleItem,
-                    enumerator1,
-                    scheduleItem.TailFiller,
-                    enumerator2,
-                    scheduleItem.FallbackFiller,
-                    enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(4);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(0);
-            enumerator3.State.Index.Should().Be(0);
-
-            playoutItems.Count.Should().Be(3);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(2);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[1].GuideGroup.Should().Be(2);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.None);
-        
-            playoutItems[2].MediaItemId.Should().Be(1);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
-            playoutItems[2].GuideGroup.Should().Be(3);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.None);
-        }
-
-        protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
-        {
-            StartTime = TimeSpan.FromHours(3)
+            Id = 1,
+            Index = 1,
+            CollectionType = ProgramScheduleItemCollectionType.Collection,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = null,
+            Count = 3
         };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+        {
+            { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems }
+        }.ToMap();
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
     }
-}
+
+    [Test]
+    public void Should_Have_Gap_With_No_Tail_No_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+
+        var scheduleItem = new ProgramScheduleItemMultiple
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = null,
+            Count = 3
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+        {
+            { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems }
+        }.ToMap();
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Exact_Tail()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+        var scheduleItem = new ProgramScheduleItemMultiple
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = null,
+            Count = 3
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+        {
+            { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+            { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems }
+        }.ToMap();
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(6);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+        var scheduleItem = new ProgramScheduleItemMultiple
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            Count = 3
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+        {
+            { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+            { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionTwo.MediaItems }
+        }.ToMap();
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(4);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Fallback);
+    }
+        
+    [Test]
+    public void Should_Have_Gap_With_Tail_No_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+
+        var scheduleItem = new ProgramScheduleItemMultiple
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = null,
+            Count = 3
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+        {
+            { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+            { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems }
+        }.ToMap();
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(6);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+            
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+        
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Tail_And_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromMinutes(55));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemMultiple
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            },
+            Count = 3
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+
+        var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+        {
+            { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+            { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems },
+            { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionThree.MediaItems }
+        }.ToMap();
+
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(
+                scheduleItem,
+                enumerator1,
+                scheduleItem.TailFiller,
+                enumerator2,
+                scheduleItem.FallbackFiller,
+                enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+        enumerator3.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(7);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddMinutes(55));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(1, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+            
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[3].GuideGroup.Should().Be(3);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[4].MediaItemId.Should().Be(4);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+        playoutItems[4].GuideGroup.Should().Be(3);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Tail);
+        
+        playoutItems[5].MediaItemId.Should().Be(3);
+        playoutItems[5].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+        playoutItems[5].GuideGroup.Should().Be(3);
+        playoutItems[5].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[6].MediaItemId.Should().Be(5);
+        playoutItems[6].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+        playoutItems[6].GuideGroup.Should().Be(3);
+        playoutItems[6].FillerKind.Should().Be(FillerKind.Fallback);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemMultiple
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            },
+            Count = 3
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+
+        var collectionMediaItems = new Dictionary<CollectionKey, List<MediaItem>>
+        {
+            { CollectionKey.ForScheduleItem(scheduleItem), collectionOne.MediaItems },
+            { CollectionKey.ForFillerPreset(scheduleItem.TailFiller), collectionTwo.MediaItems },
+            { CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller), collectionThree.MediaItems }
+        }.ToMap();
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerMultiple(collectionMediaItems, new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(
+                scheduleItem,
+                enumerator1,
+                scheduleItem.TailFiller,
+                enumerator2,
+                scheduleItem.FallbackFiller,
+                enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(4);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(0);
+        enumerator3.State.Index.Should().Be(0);
+
+        playoutItems.Count.Should().Be(3);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(2);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[1].GuideGroup.Should().Be(2);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.None);
+        
+        playoutItems[2].MediaItemId.Should().Be(1);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.AddHours(2));
+        playoutItems[2].GuideGroup.Should().Be(3);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.None);
+    }
+
+    protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+    {
+        StartTime = TimeSpan.FromHours(3)
+    };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerOneTests.cs b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerOneTests.cs
index 13d5836b2..ab11ed92f 100644
--- a/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerOneTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/PlayoutModeSchedulerOneTests.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
@@ -9,752 +6,751 @@ using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class PlayoutModeSchedulerOneTests : SchedulerTestBase
 {
-    [TestFixture]
-    public class PlayoutModeSchedulerOneTests : SchedulerTestBase
+    [Test]
+    public void Should_Have_Gap_With_No_Tail_No_Fallback()
     {
-        [Test]
-        public void Should_Have_Gap_With_No_Tail_No_Fallback()
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+
+        var scheduleItem = new ProgramScheduleItemOne
         {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = null
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(1);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-        }
-
-        [Test]
-        public void Should_Have_Gap_With_Empty_Tail_Empty_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-            var collectionTwo = new Collection { Id = 2, Name = "Collection 2", MediaItems = new List<MediaItem>() };
-            var collectionThree = new Collection { Id = 3, Name = "Collection 3", MediaItems = new List<MediaItem>() };
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    CollectionId = collectionTwo.Id,
-                    Collection = collectionTwo
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    CollectionId = collectionThree.Id,
-                    Collection = collectionThree
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(0);
-            enumerator3.State.Index.Should().Be(0);
-
-            playoutItems.Count.Should().Be(1);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Exact_Tail()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = null
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(4);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[1].GuideGroup.Should().Be(1);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(1);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
-        
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
-            playoutItems[3].GuideGroup.Should().Be(1);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = null,
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(2);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
-            playoutItems[1].GuideGroup.Should().Be(1);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.Fallback);
-        }
-        
-        [Test]
-        public void Should_Have_Gap_With_Tail_No_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = null
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(4);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[1].GuideGroup.Should().Be(1);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
-            playoutItems[2].GuideGroup.Should().Be(1);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
-        
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
-            playoutItems[3].GuideGroup.Should().Be(1);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Tail_And_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(
-                    scheduleItem,
-                    enumerator1,
-                    scheduleItem.TailFiller,
-                    enumerator2,
-                    scheduleItem.FallbackFiller,
-                    enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-            enumerator3.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(5);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[1].GuideGroup.Should().Be(1);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
-            playoutItems[2].GuideGroup.Should().Be(1);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
-        
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
-            playoutItems[3].GuideGroup.Should().Be(1);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
-
-            playoutItems[4].MediaItemId.Should().Be(5);
-            playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
-            playoutItems[4].GuideGroup.Should().Be(1);
-            playoutItems[4].FillerKind.Should().Be(FillerKind.Fallback);
-        }
-
-        [Test]
-        public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(3));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                TailFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Tail,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-            
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(
-                    scheduleItem,
-                    enumerator1,
-                    scheduleItem.TailFiller,
-                    enumerator2,
-                    scheduleItem.FallbackFiller,
-                    enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(0);
-            enumerator3.State.Index.Should().Be(0);
-
-            playoutItems.Count.Should().Be(1);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-        }
-
-        [Test]
-        public void Should_Have_No_Gap_With_Exact_Post_Roll_Pad()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                PostRollFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.PostRoll,
-                    FillerMode = FillerMode.Pad,
-                    PadToNearestMinute = 30,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-
-            playoutItems.Count.Should().Be(4);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[1].GuideGroup.Should().Be(1);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
-
-            playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(1);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.PostRoll);
-        
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
-            playoutItems[3].GuideGroup.Should().Be(1);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
-        }
-
-        [Test]
-        public void Should_Have_No_Gap_With_Exact_Post_Roll_Pad_With_Chapters()
-        {
-            Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0), 2);
-            Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
-            Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
-
-            var scheduleItem = new ProgramScheduleItemOne
-            {
-                Id = 1,
-                Index = 1,
-                Collection = collectionOne,
-                CollectionId = collectionOne.Id,
-                StartTime = null,
-                PlaybackOrder = PlaybackOrder.Chronological,
-                PostRollFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.PostRoll,
-                    FillerMode = FillerMode.Pad,
-                    PadToNearestMinute = 30,
-                    Collection = collectionTwo,
-                    CollectionId = collectionTwo.Id
-                },
-                FallbackFiller = new FillerPreset
-                {
-                    FillerKind = FillerKind.Fallback,
-                    Collection = collectionThree,
-                    CollectionId = collectionThree.Id
-                }
-            };
-            
-            var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
-                new List<ProgramScheduleItem> { scheduleItem },
-                new CollectionEnumeratorState());
-
-            var enumerator1 = new ChronologicalMediaCollectionEnumerator(
-                collectionOne.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator2 = new ChronologicalMediaCollectionEnumerator(
-                collectionTwo.MediaItems,
-                new CollectionEnumeratorState());
-
-            var enumerator3 = new ChronologicalMediaCollectionEnumerator(
-                collectionThree.MediaItems,
-                new CollectionEnumeratorState());
-
-            PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
-
-            var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
-            (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
-                startState,
-                CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
-                scheduleItem,
-                NextScheduleItem,
-                HardStop(scheduleItemsEnumerator));
-
-            playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
-            playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
-
-            playoutBuilderState.NextGuideGroup.Should().Be(2);
-            playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
-            playoutBuilderState.InFlood.Should().BeFalse();
-            playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
-            playoutBuilderState.InDurationFiller.Should().BeFalse();
-            playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
-
-            enumerator1.State.Index.Should().Be(1);
-            enumerator2.State.Index.Should().Be(1);
-            enumerator3.State.Index.Should().Be(0);
-
-            playoutItems.Count.Should().Be(4);
-
-            playoutItems[0].MediaItemId.Should().Be(1);
-            playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
-            playoutItems[0].GuideGroup.Should().Be(1);
-            playoutItems[0].FillerKind.Should().Be(FillerKind.None);
-
-            playoutItems[1].MediaItemId.Should().Be(3);
-            playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
-            playoutItems[1].GuideGroup.Should().Be(1);
-            playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
-
-            playoutItems[2].MediaItemId.Should().Be(4);
-            playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
-            playoutItems[2].GuideGroup.Should().Be(1);
-            playoutItems[2].FillerKind.Should().Be(FillerKind.PostRoll);
-        
-            playoutItems[3].MediaItemId.Should().Be(3);
-            playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
-            playoutItems[3].GuideGroup.Should().Be(1);
-            playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
-        }
-
-        protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
-        {
-            StartTime = TimeSpan.FromHours(3)
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = null
         };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(1);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
     }
-}
+
+    [Test]
+    public void Should_Have_Gap_With_Empty_Tail_Empty_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+        var collectionTwo = new Collection { Id = 2, Name = "Collection 2", MediaItems = new List<MediaItem>() };
+        var collectionThree = new Collection { Id = 3, Name = "Collection 3", MediaItems = new List<MediaItem>() };
+
+        var scheduleItem = new ProgramScheduleItemOne
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                CollectionId = collectionTwo.Id,
+                Collection = collectionTwo
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                CollectionId = collectionThree.Id,
+                Collection = collectionThree
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(0);
+        enumerator3.State.Index.Should().Be(0);
+
+        playoutItems.Count.Should().Be(1);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Exact_Tail()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+        var scheduleItem = new ProgramScheduleItemOne
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = null
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(4);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(3);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[1].GuideGroup.Should().Be(1);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[2].MediaItemId.Should().Be(4);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(1);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
+        
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+        playoutItems[3].GuideGroup.Should().Be(1);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(1));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+
+        var scheduleItem = new ProgramScheduleItemOne
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = null,
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.FallbackFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(2);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(3);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.AddHours(1));
+        playoutItems[1].GuideGroup.Should().Be(1);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.Fallback);
+    }
+        
+    [Test]
+    public void Should_Have_Gap_With_Tail_No_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+
+        var scheduleItem = new ProgramScheduleItemOne
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = null
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.TailFiller, enumerator2),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(4);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(3);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[1].GuideGroup.Should().Be(1);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[2].MediaItemId.Should().Be(4);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+        playoutItems[2].GuideGroup.Should().Be(1);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
+        
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+        playoutItems[3].GuideGroup.Should().Be(1);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Tail_And_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemOne
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(
+                scheduleItem,
+                enumerator1,
+                scheduleItem.TailFiller,
+                enumerator2,
+                scheduleItem.FallbackFiller,
+                enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+        enumerator3.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(5);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(3);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[1].GuideGroup.Should().Be(1);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[2].MediaItemId.Should().Be(4);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 49, 0)));
+        playoutItems[2].GuideGroup.Should().Be(1);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.Tail);
+        
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 53, 0)));
+        playoutItems[3].GuideGroup.Should().Be(1);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.Tail);
+
+        playoutItems[4].MediaItemId.Should().Be(5);
+        playoutItems[4].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 57, 0)));
+        playoutItems[4].GuideGroup.Should().Be(1);
+        playoutItems[4].FillerKind.Should().Be(FillerKind.Fallback);
+    }
+
+    [Test]
+    public void Should_Not_Have_Gap_With_Unused_Tail_And_Unused_Fallback()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, TimeSpan.FromHours(3));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(4));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemOne
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            TailFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Tail,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+            
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(
+                scheduleItem,
+                enumerator1,
+                scheduleItem.TailFiller,
+                enumerator2,
+                scheduleItem.FallbackFiller,
+                enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(0);
+        enumerator3.State.Index.Should().Be(0);
+
+        playoutItems.Count.Should().Be(1);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+    }
+
+    [Test]
+    public void Should_Have_No_Gap_With_Exact_Post_Roll_Pad()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0));
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemOne
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            PostRollFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.PostRoll,
+                FillerMode = FillerMode.Pad,
+                PadToNearestMinute = 30,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+
+        playoutItems.Count.Should().Be(4);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(3);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[1].GuideGroup.Should().Be(1);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
+
+        playoutItems[2].MediaItemId.Should().Be(4);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(1);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.PostRoll);
+        
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+        playoutItems[3].GuideGroup.Should().Be(1);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
+    }
+
+    [Test]
+    public void Should_Have_No_Gap_With_Exact_Post_Roll_Pad_With_Chapters()
+    {
+        Collection collectionOne = TwoItemCollection(1, 2, new TimeSpan(2, 45, 0), 2);
+        Collection collectionTwo = TwoItemCollection(3, 4, TimeSpan.FromMinutes(5));
+        Collection collectionThree = TwoItemCollection(5, 6, TimeSpan.FromMinutes(1));
+
+        var scheduleItem = new ProgramScheduleItemOne
+        {
+            Id = 1,
+            Index = 1,
+            Collection = collectionOne,
+            CollectionId = collectionOne.Id,
+            StartTime = null,
+            PlaybackOrder = PlaybackOrder.Chronological,
+            PostRollFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.PostRoll,
+                FillerMode = FillerMode.Pad,
+                PadToNearestMinute = 30,
+                Collection = collectionTwo,
+                CollectionId = collectionTwo.Id
+            },
+            FallbackFiller = new FillerPreset
+            {
+                FillerKind = FillerKind.Fallback,
+                Collection = collectionThree,
+                CollectionId = collectionThree.Id
+            }
+        };
+            
+        var scheduleItemsEnumerator = new OrderedScheduleItemsEnumerator(
+            new List<ProgramScheduleItem> { scheduleItem },
+            new CollectionEnumeratorState());
+
+        var enumerator1 = new ChronologicalMediaCollectionEnumerator(
+            collectionOne.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator2 = new ChronologicalMediaCollectionEnumerator(
+            collectionTwo.MediaItems,
+            new CollectionEnumeratorState());
+
+        var enumerator3 = new ChronologicalMediaCollectionEnumerator(
+            collectionThree.MediaItems,
+            new CollectionEnumeratorState());
+
+        PlayoutBuilderState startState = StartState(scheduleItemsEnumerator);
+
+        var scheduler = new PlayoutModeSchedulerOne(new Mock<ILogger>().Object);
+        (PlayoutBuilderState playoutBuilderState, List<PlayoutItem> playoutItems) = scheduler.Schedule(
+            startState,
+            CollectionEnumerators(scheduleItem, enumerator1, scheduleItem.PostRollFiller, enumerator2, scheduleItem.FallbackFiller, enumerator3),
+            scheduleItem,
+            NextScheduleItem,
+            HardStop(scheduleItemsEnumerator));
+
+        playoutBuilderState.CurrentTime.Should().Be(startState.CurrentTime.AddHours(3));
+        playoutItems.Last().FinishOffset.Should().Be(playoutBuilderState.CurrentTime);
+
+        playoutBuilderState.NextGuideGroup.Should().Be(2);
+        playoutBuilderState.DurationFinish.IsNone.Should().BeTrue();
+        playoutBuilderState.InFlood.Should().BeFalse();
+        playoutBuilderState.MultipleRemaining.IsNone.Should().BeTrue();
+        playoutBuilderState.InDurationFiller.Should().BeFalse();
+        playoutBuilderState.ScheduleItemsEnumerator.State.Index.Should().Be(0);
+
+        enumerator1.State.Index.Should().Be(1);
+        enumerator2.State.Index.Should().Be(1);
+        enumerator3.State.Index.Should().Be(0);
+
+        playoutItems.Count.Should().Be(4);
+
+        playoutItems[0].MediaItemId.Should().Be(1);
+        playoutItems[0].StartOffset.Should().Be(startState.CurrentTime);
+        playoutItems[0].GuideGroup.Should().Be(1);
+        playoutItems[0].FillerKind.Should().Be(FillerKind.None);
+
+        playoutItems[1].MediaItemId.Should().Be(3);
+        playoutItems[1].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 45, 0)));
+        playoutItems[1].GuideGroup.Should().Be(1);
+        playoutItems[1].FillerKind.Should().Be(FillerKind.PostRoll);
+
+        playoutItems[2].MediaItemId.Should().Be(4);
+        playoutItems[2].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 50, 0)));
+        playoutItems[2].GuideGroup.Should().Be(1);
+        playoutItems[2].FillerKind.Should().Be(FillerKind.PostRoll);
+        
+        playoutItems[3].MediaItemId.Should().Be(3);
+        playoutItems[3].StartOffset.Should().Be(startState.CurrentTime.Add(new TimeSpan(2, 55, 0)));
+        playoutItems[3].GuideGroup.Should().Be(1);
+        playoutItems[3].FillerKind.Should().Be(FillerKind.PostRoll);
+    }
+
+    protected override ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+    {
+        StartTime = TimeSpan.FromHours(3)
+    };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/RandomizedContentTests.cs b/ErsatzTV.Core.Tests/Scheduling/RandomizedContentTests.cs
index accefa35a..cb7f6055c 100644
--- a/ErsatzTV.Core.Tests/Scheduling/RandomizedContentTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/RandomizedContentTests.cs
@@ -1,107 +1,102 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class RandomizedContentTests
 {
-    [TestFixture]
-    public class RandomizedContentTests
+    private const int KnownSeed = 22295;
+
+    private readonly List<int> _expected = new()
     {
-        private const int KnownSeed = 22295;
+        5, 7, 7, 8, 6, 7, 8, 9, 10, 7, 5, 1, 7, 2, 5, 6, 1, 4, 5, 6, 4, 5, 1, 6, 5, 7, 1, 3, 9, 9, 9, 3,
+        3, 2, 3, 4, 5, 6, 9, 3, 6, 9, 7, 1, 2, 10, 3, 8, 3, 8, 8, 3, 1, 5, 4, 3, 6, 4, 6, 2, 9, 8, 3, 1, 8, 5,
+        1, 8, 2, 1, 1, 5, 5, 5, 3, 5, 8, 10, 4, 8, 7, 3, 3, 4, 4, 9, 2, 8, 8, 10, 8, 4, 3, 10, 7, 8, 9, 9
+    };
 
-        private readonly List<int> _expected = new()
+    [Test]
+    public void Episodes_Should_Randomize()
+    {
+        List<MediaItem> contents = Episodes(10);
+
+        var state = new CollectionEnumeratorState();
+
+        var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
+
+        var list = new List<int>();
+        for (var i = 1; i <= 10; i++)
         {
-            5, 7, 7, 8, 6, 7, 8, 9, 10, 7, 5, 1, 7, 2, 5, 6, 1, 4, 5, 6, 4, 5, 1, 6, 5, 7, 1, 3, 9, 9, 9, 3,
-            3, 2, 3, 4, 5, 6, 9, 3, 6, 9, 7, 1, 2, 10, 3, 8, 3, 8, 8, 3, 1, 5, 4, 3, 6, 4, 6, 2, 9, 8, 3, 1, 8, 5,
-            1, 8, 2, 1, 1, 5, 5, 5, 3, 5, 8, 10, 4, 8, 7, 3, 3, 4, 4, 9, 2, 8, 8, 10, 8, 4, 3, 10, 7, 8, 9, 9
-        };
+            randomizedContent.Current.IsSome.Should().BeTrue();
+            randomizedContent.Current.Do(c => list.Add(c.Id));
 
-        [Test]
-        public void Episodes_Should_Randomize()
-        {
-            List<MediaItem> contents = Episodes(10);
-
-            var state = new CollectionEnumeratorState();
-
-            var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
-
-            var list = new List<int>();
-            for (var i = 1; i <= 10; i++)
-            {
-                randomizedContent.Current.IsSome.Should().BeTrue();
-                randomizedContent.Current.Do(c => list.Add(c.Id));
-
-                randomizedContent.MoveNext();
-            }
-
-            list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
-            list.Should().NotEqual(new[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 });
+            randomizedContent.MoveNext();
         }
 
-        [Test]
-        public void State_Index_Should_Increment()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
-
-            for (var i = 1; i <= 10; i++)
-            {
-                randomizedContent.State.Index.Should().Be(i);
-
-                randomizedContent.MoveNext();
-            }
-        }
-
-        [Test]
-        public void State_Should_Impact_Iterator_Start()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 5, Seed = KnownSeed };
-
-            var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
-
-            for (var i = 6; i <= 99; i++)
-            {
-                randomizedContent.Current.IsSome.Should().BeTrue();
-                // this test data setup/expectation is confusing
-                randomizedContent.Current.Map(c => c.Id).IfNone(-1).Should().Be(_expected[i - 2]);
-                randomizedContent.State.Index.Should().Be(i);
-
-                randomizedContent.MoveNext();
-            }
-        }
-
-        [Test]
-        [Timeout(1000)]
-        public void State_Index_Should_Continue_Past_End_Of_Items()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 10, Seed = KnownSeed };
-
-            var _ = new RandomizedMediaCollectionEnumerator(contents, state);
-        }
-
-        private static List<MediaItem> Episodes(int count) =>
-            Range(1, count).Map(
-                    i => (MediaItem) new Episode
-                    {
-                        Id = i,
-                        EpisodeMetadata = new List<EpisodeMetadata>
-                        {
-                            new()
-                            {
-                                ReleaseDate = new DateTime(2020, 1, i)
-                            }
-                        }
-                    })
-                .Reverse()
-                .ToList();
+        list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
+        list.Should().NotEqual(new[] { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 });
     }
-}
+
+    [Test]
+    public void State_Index_Should_Increment()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
+
+        for (var i = 1; i <= 10; i++)
+        {
+            randomizedContent.State.Index.Should().Be(i);
+
+            randomizedContent.MoveNext();
+        }
+    }
+
+    [Test]
+    public void State_Should_Impact_Iterator_Start()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 5, Seed = KnownSeed };
+
+        var randomizedContent = new RandomizedMediaCollectionEnumerator(contents, state);
+
+        for (var i = 6; i <= 99; i++)
+        {
+            randomizedContent.Current.IsSome.Should().BeTrue();
+            // this test data setup/expectation is confusing
+            randomizedContent.Current.Map(c => c.Id).IfNone(-1).Should().Be(_expected[i - 2]);
+            randomizedContent.State.Index.Should().Be(i);
+
+            randomizedContent.MoveNext();
+        }
+    }
+
+    [Test]
+    [Timeout(1000)]
+    public void State_Index_Should_Continue_Past_End_Of_Items()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 10, Seed = KnownSeed };
+
+        var _ = new RandomizedMediaCollectionEnumerator(contents, state);
+    }
+
+    private static List<MediaItem> Episodes(int count) =>
+        Range(1, count).Map(
+                i => (MediaItem) new Episode
+                {
+                    Id = i,
+                    EpisodeMetadata = new List<EpisodeMetadata>
+                    {
+                        new()
+                        {
+                            ReleaseDate = new DateTime(2020, 1, i)
+                        }
+                    }
+                })
+            .Reverse()
+            .ToList();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/SchedulerTestBase.cs b/ErsatzTV.Core.Tests/Scheduling/SchedulerTestBase.cs
index ef97340f8..4938b367a 100644
--- a/ErsatzTV.Core.Tests/Scheduling/SchedulerTestBase.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/SchedulerTestBase.cs
@@ -1,93 +1,89 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using ErsatzTV.Core.Scheduling;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+public abstract class SchedulerTestBase
 {
-    public abstract class SchedulerTestBase
-    {
-        protected static PlayoutBuilderState StartState(IScheduleItemsEnumerator scheduleItemsEnumerator) => new(
-            scheduleItemsEnumerator,
-            Prelude.None,
-            Prelude.None,
-            false,
-            false,
-            1,
-            new DateTimeOffset(new DateTime(2020, 10, 18, 0, 0, 0, DateTimeKind.Local)));
+    protected static PlayoutBuilderState StartState(IScheduleItemsEnumerator scheduleItemsEnumerator) => new(
+        scheduleItemsEnumerator,
+        Prelude.None,
+        Prelude.None,
+        false,
+        false,
+        1,
+        new DateTimeOffset(new DateTime(2020, 10, 18, 0, 0, 0, DateTimeKind.Local)));
 
-        protected virtual ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+    protected virtual ProgramScheduleItem NextScheduleItem => new ProgramScheduleItemOne
+    {
+        StartTime = null
+    };
+
+    protected static DateTimeOffset HardStop(IScheduleItemsEnumerator scheduleItemsEnumerator) =>
+        StartState(scheduleItemsEnumerator).CurrentTime.AddHours(6);
+
+    protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
+        ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator) =>
+        new()
         {
-            StartTime = null
+            { CollectionKey.ForScheduleItem(scheduleItem), enumerator }
         };
 
-        protected static DateTimeOffset HardStop(IScheduleItemsEnumerator scheduleItemsEnumerator) =>
-            StartState(scheduleItemsEnumerator).CurrentTime.AddHours(6);
-
-        protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
-            ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator) =>
-            new()
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), enumerator }
-            };
-
-        protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
-            ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator1,
-            FillerPreset fillerPreset, IMediaCollectionEnumerator enumerator2,
-            FillerPreset fillerPreset2, IMediaCollectionEnumerator enumerator3) =>
-            new()
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), enumerator1 },
-                { CollectionKey.ForFillerPreset(fillerPreset), enumerator2 },
-                { CollectionKey.ForFillerPreset(fillerPreset2), enumerator3 }
-            };
-
-        private static Movie TestMovie(int id, TimeSpan duration, DateTime aired, int chapterCount = 0)
+    protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
+        ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator1,
+        FillerPreset fillerPreset, IMediaCollectionEnumerator enumerator2,
+        FillerPreset fillerPreset2, IMediaCollectionEnumerator enumerator3) =>
+        new()
         {
-            var result = new Movie()
-            {
-                Id = id,
-                MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
-                MediaVersions = new List<MediaVersion>
-                {
-                    new() { Duration = duration, Chapters = new List<MediaChapter>() }
-                }
-            };
+            { CollectionKey.ForScheduleItem(scheduleItem), enumerator1 },
+            { CollectionKey.ForFillerPreset(fillerPreset), enumerator2 },
+            { CollectionKey.ForFillerPreset(fillerPreset2), enumerator3 }
+        };
 
-            for (var i = 0; i < chapterCount; i++)
+    private static Movie TestMovie(int id, TimeSpan duration, DateTime aired, int chapterCount = 0)
+    {
+        var result = new Movie()
+        {
+            Id = id,
+            MovieMetadata = new List<MovieMetadata> { new() { ReleaseDate = aired } },
+            MediaVersions = new List<MediaVersion>
             {
-                result.MediaVersions.Head().Chapters.Add(
-                    new MediaChapter
-                    {
-                        StartTime = TimeSpan.FromMilliseconds(i * duration.TotalMilliseconds / chapterCount),
-                        EndTime = TimeSpan.FromMilliseconds(i + 1 * duration.TotalMilliseconds / chapterCount)
-                    });
+                new() { Duration = duration, Chapters = new List<MediaChapter>() }
             }
+        };
 
-            return result;
+        for (var i = 0; i < chapterCount; i++)
+        {
+            result.MediaVersions.Head().Chapters.Add(
+                new MediaChapter
+                {
+                    StartTime = TimeSpan.FromMilliseconds(i * duration.TotalMilliseconds / chapterCount),
+                    EndTime = TimeSpan.FromMilliseconds(i + 1 * duration.TotalMilliseconds / chapterCount)
+                });
         }
 
-        protected static Collection TwoItemCollection(int id1, int id2, TimeSpan duration, int chapterCount = 0) => new()
-        {
-            Id = id1,
-            Name = $"Collection of Items {id1}",
-            MediaItems = new List<MediaItem>
-            {
-                TestMovie(id1, duration, new DateTime(2020, 1, 1), chapterCount),
-                TestMovie(id2, duration, new DateTime(2020, 1, 2), chapterCount)
-            }
-        };
-
-        protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
-            ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator1,
-            FillerPreset fillerPreset, IMediaCollectionEnumerator enumerator2) =>
-            new()
-            {
-                { CollectionKey.ForScheduleItem(scheduleItem), enumerator1 },
-                { CollectionKey.ForFillerPreset(fillerPreset), enumerator2 }
-            };
+        return result;
     }
-}
+
+    protected static Collection TwoItemCollection(int id1, int id2, TimeSpan duration, int chapterCount = 0) => new()
+    {
+        Id = id1,
+        Name = $"Collection of Items {id1}",
+        MediaItems = new List<MediaItem>
+        {
+            TestMovie(id1, duration, new DateTime(2020, 1, 1), chapterCount),
+            TestMovie(id2, duration, new DateTime(2020, 1, 2), chapterCount)
+        }
+    };
+
+    protected static Dictionary<CollectionKey, IMediaCollectionEnumerator> CollectionEnumerators(
+        ProgramScheduleItem scheduleItem, IMediaCollectionEnumerator enumerator1,
+        FillerPreset fillerPreset, IMediaCollectionEnumerator enumerator2) =>
+        new()
+        {
+            { CollectionKey.ForScheduleItem(scheduleItem), enumerator1 },
+            { CollectionKey.ForFillerPreset(fillerPreset), enumerator2 }
+        };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/ShuffledContentTests.cs b/ErsatzTV.Core.Tests/Scheduling/ShuffledContentTests.cs
index 46ea690cf..306fdf84c 100644
--- a/ErsatzTV.Core.Tests/Scheduling/ShuffledContentTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/ShuffledContentTests.cs
@@ -1,154 +1,149 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
 using NUnit.Framework;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class ShuffledContentTests
 {
-    [TestFixture]
-    public class ShuffledContentTests
+    // this seed will produce (shuffle) 1-10 in order
+    private const int MagicSeed = 670596;
+
+    [Test]
+    public void Episodes_Should_Not_Duplicate_When_Reshuffling()
     {
-        // this seed will produce (shuffle) 1-10 in order
-        private const int MagicSeed = 670596;
+        List<MediaItem> contents = Episodes(10);
 
-        [Test]
-        public void Episodes_Should_Not_Duplicate_When_Reshuffling()
+        // normally returns 10 5 7 4 3 6 2 8 9 1 1 (note duplicate 1 at end)
+        var state = new CollectionEnumeratorState { Seed = 8 };
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        var list = new List<int>();
+        for (var i = 1; i <= 1000; i++)
         {
-            List<MediaItem> contents = Episodes(10);
-
-            // normally returns 10 5 7 4 3 6 2 8 9 1 1 (note duplicate 1 at end)
-            var state = new CollectionEnumeratorState { Seed = 8 };
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            var list = new List<int>();
-            for (var i = 1; i <= 1000; i++)
-            {
-                shuffledContent.Current.IsSome.Should().BeTrue();
-                shuffledContent.Current.Do(x => list.Add(x.Id));
-                shuffledContent.MoveNext();
-            }
-
-            for (var i = 0; i < list.Count - 1; i++)
-            {
-                if (list[i] == list[i + 1])
-                {
-                    Assert.Fail("List contains duplicate items");
-                }
-            }
+            shuffledContent.Current.IsSome.Should().BeTrue();
+            shuffledContent.Current.Do(x => list.Add(x.Id));
+            shuffledContent.MoveNext();
         }
 
-        [Test]
-        [Timeout(2000)]
-        public void Duplicate_Check_Should_Ignore_Single_Item()
+        for (var i = 0; i < list.Count - 1; i++)
         {
-            List<MediaItem> contents = Episodes(1);
-
-            var state = new CollectionEnumeratorState();
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            var list = new List<int>();
-            for (var i = 1; i <= 10; i++)
+            if (list[i] == list[i + 1])
             {
-                shuffledContent.Current.IsSome.Should().BeTrue();
-                shuffledContent.Current.Do(x => list.Add(x.Id));
-                shuffledContent.MoveNext();
-            }
-
-            list.Should().Equal(1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
-        }
-
-        [Test]
-        public void Episodes_Should_Shuffle()
-        {
-            List<MediaItem> contents = Episodes(10);
-
-            var state = new CollectionEnumeratorState();
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            var list = new List<int>();
-            for (var i = 1; i <= 10; i++)
-            {
-                shuffledContent.Current.IsSome.Should().BeTrue();
-                shuffledContent.Current.Do(x => list.Add(x.Id));
-                shuffledContent.MoveNext();
-            }
-
-            list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
-            list.Should().BeEquivalentTo(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
-        }
-
-        [Test]
-        public void State_Index_Should_Increment()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState();
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            for (var i = 0; i < 10; i++)
-            {
-                shuffledContent.State.Index.Should().Be(i);
-                shuffledContent.MoveNext();
+                Assert.Fail("List contains duplicate items");
             }
         }
-
-        [Test]
-        public void State_Should_Impact_Iterator_Start()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 5, Seed = MagicSeed };
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            for (var i = 6; i <= 10; i++)
-            {
-                shuffledContent.Current.IsSome.Should().BeTrue();
-                shuffledContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
-                shuffledContent.State.Index.Should().Be(i - 1);
-                shuffledContent.MoveNext();
-            }
-        }
-
-        [Test]
-        [Timeout(1000)]
-        public void State_Should_Reset_When_Invalid()
-        {
-            List<MediaItem> contents = Episodes(10);
-            var state = new CollectionEnumeratorState { Index = 10, Seed = MagicSeed };
-
-            var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-            var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
-
-            shuffledContent.State.Index.Should().Be(0);
-            shuffledContent.State.Seed.Should().NotBe(MagicSeed);
-        }
-
-        private static List<MediaItem> Episodes(int count) =>
-            Range(1, count).Map(
-                    i => (MediaItem) new Episode
-                    {
-                        Id = i,
-                        EpisodeMetadata = new List<EpisodeMetadata>
-                        {
-                            new()
-                            {
-                                ReleaseDate = new DateTime(2020, 1, i)
-                            }
-                        }
-                    })
-                .Reverse()
-                .ToList();
     }
-}
+
+    [Test]
+    [Timeout(2000)]
+    public void Duplicate_Check_Should_Ignore_Single_Item()
+    {
+        List<MediaItem> contents = Episodes(1);
+
+        var state = new CollectionEnumeratorState();
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        var list = new List<int>();
+        for (var i = 1; i <= 10; i++)
+        {
+            shuffledContent.Current.IsSome.Should().BeTrue();
+            shuffledContent.Current.Do(x => list.Add(x.Id));
+            shuffledContent.MoveNext();
+        }
+
+        list.Should().Equal(1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+    }
+
+    [Test]
+    public void Episodes_Should_Shuffle()
+    {
+        List<MediaItem> contents = Episodes(10);
+
+        var state = new CollectionEnumeratorState();
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        var list = new List<int>();
+        for (var i = 1; i <= 10; i++)
+        {
+            shuffledContent.Current.IsSome.Should().BeTrue();
+            shuffledContent.Current.Do(x => list.Add(x.Id));
+            shuffledContent.MoveNext();
+        }
+
+        list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
+        list.Should().BeEquivalentTo(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
+    }
+
+    [Test]
+    public void State_Index_Should_Increment()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState();
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        for (var i = 0; i < 10; i++)
+        {
+            shuffledContent.State.Index.Should().Be(i);
+            shuffledContent.MoveNext();
+        }
+    }
+
+    [Test]
+    public void State_Should_Impact_Iterator_Start()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 5, Seed = MagicSeed };
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        for (var i = 6; i <= 10; i++)
+        {
+            shuffledContent.Current.IsSome.Should().BeTrue();
+            shuffledContent.Current.Map(x => x.Id).IfNone(-1).Should().Be(i);
+            shuffledContent.State.Index.Should().Be(i - 1);
+            shuffledContent.MoveNext();
+        }
+    }
+
+    [Test]
+    [Timeout(1000)]
+    public void State_Should_Reset_When_Invalid()
+    {
+        List<MediaItem> contents = Episodes(10);
+        var state = new CollectionEnumeratorState { Index = 10, Seed = MagicSeed };
+
+        var groupedMediaItems = contents.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+        var shuffledContent = new ShuffledMediaCollectionEnumerator(groupedMediaItems, state);
+
+        shuffledContent.State.Index.Should().Be(0);
+        shuffledContent.State.Seed.Should().NotBe(MagicSeed);
+    }
+
+    private static List<MediaItem> Episodes(int count) =>
+        Range(1, count).Map(
+                i => (MediaItem) new Episode
+                {
+                    Id = i,
+                    EpisodeMetadata = new List<EpisodeMetadata>
+                    {
+                        new()
+                        {
+                            ReleaseDate = new DateTime(2020, 1, i)
+                        }
+                    }
+                })
+            .Reverse()
+            .ToList();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core.Tests/Scheduling/ShuffledMediaCollectionEnumeratorTests.cs b/ErsatzTV.Core.Tests/Scheduling/ShuffledMediaCollectionEnumeratorTests.cs
index 3f861006a..0ab61d337 100644
--- a/ErsatzTV.Core.Tests/Scheduling/ShuffledMediaCollectionEnumeratorTests.cs
+++ b/ErsatzTV.Core.Tests/Scheduling/ShuffledMediaCollectionEnumeratorTests.cs
@@ -1,90 +1,87 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using FluentAssertions;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using NUnit.Framework;
 
-namespace ErsatzTV.Core.Tests.Scheduling
+namespace ErsatzTV.Core.Tests.Scheduling;
+
+[TestFixture]
+public class ShuffledMediaCollectionEnumeratorTests
 {
-    [TestFixture]
-    public class ShuffledMediaCollectionEnumeratorTests
+    private readonly List<GroupedMediaItem> _mediaItems = new()
     {
-        private readonly List<GroupedMediaItem> _mediaItems = new()
-        {
-            new GroupedMediaItem(new MediaItem { Id = 1 }, new List<MediaItem>()),
-            new GroupedMediaItem(new MediaItem { Id = 2 }, new List<MediaItem>()),
-            new GroupedMediaItem(new MediaItem { Id = 3 }, new List<MediaItem>())
-        };
+        new GroupedMediaItem(new MediaItem { Id = 1 }, new List<MediaItem>()),
+        new GroupedMediaItem(new MediaItem { Id = 2 }, new List<MediaItem>()),
+        new GroupedMediaItem(new MediaItem { Id = 3 }, new List<MediaItem>())
+    };
         
-        [Test]
-        public void Peek_Zero_Should_Match_Current()
-        {
-            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
-            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+    [Test]
+    public void Peek_Zero_Should_Match_Current()
+    {
+        var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+        var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
 
-            Option<MediaItem> peek = enumerator.Peek(0);
-            Option<MediaItem> current = enumerator.Current;
+        Option<MediaItem> peek = enumerator.Peek(0);
+        Option<MediaItem> current = enumerator.Current;
 
-            peek.IsSome.Should().BeTrue();
-            current.IsSome.Should().BeTrue();
-            peek.ValueUnsafe().Id.Should().Be(1);
-            current.ValueUnsafe().Id.Should().Be(1);
-        }
-        
-        [Test]
-        public void Peek_One_Should_Match_Next()
-        {
-            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
-            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
-
-            Option<MediaItem> peek = enumerator.Peek(1);
-
-            enumerator.MoveNext();
-            Option<MediaItem> next = enumerator.Current;
-
-            peek.IsSome.Should().BeTrue();
-            next.IsSome.Should().BeTrue();
-            peek.ValueUnsafe().Id.Should().Be(2);
-            next.ValueUnsafe().Id.Should().Be(2);
-        }
-        
-        [Test]
-        public void Peek_Two_Should_Match_NextNext()
-        {
-            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
-            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
-
-            Option<MediaItem> peek = enumerator.Peek(2);
-
-            enumerator.MoveNext();
-            enumerator.MoveNext();
-            Option<MediaItem> next = enumerator.Current;
-
-            peek.IsSome.Should().BeTrue();
-            next.IsSome.Should().BeTrue();
-            peek.ValueUnsafe().Id.Should().Be(3);
-            next.ValueUnsafe().Id.Should().Be(3);
-        }
-        
-        [Test]
-        public void Peek_Three_Should_Match_NextNextNext()
-        {
-            var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
-            var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
-
-            Option<MediaItem> peek = enumerator.Peek(3);
-
-            enumerator.MoveNext();
-            enumerator.MoveNext();
-            enumerator.MoveNext();
-            Option<MediaItem> next = enumerator.Current;
-
-            peek.IsSome.Should().BeTrue();
-            next.IsSome.Should().BeTrue();
-            peek.ValueUnsafe().Id.Should().Be(2);
-            next.ValueUnsafe().Id.Should().Be(2);
-        }
+        peek.IsSome.Should().BeTrue();
+        current.IsSome.Should().BeTrue();
+        peek.ValueUnsafe().Id.Should().Be(1);
+        current.ValueUnsafe().Id.Should().Be(1);
     }
-}
+        
+    [Test]
+    public void Peek_One_Should_Match_Next()
+    {
+        var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+        var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+        Option<MediaItem> peek = enumerator.Peek(1);
+
+        enumerator.MoveNext();
+        Option<MediaItem> next = enumerator.Current;
+
+        peek.IsSome.Should().BeTrue();
+        next.IsSome.Should().BeTrue();
+        peek.ValueUnsafe().Id.Should().Be(2);
+        next.ValueUnsafe().Id.Should().Be(2);
+    }
+        
+    [Test]
+    public void Peek_Two_Should_Match_NextNext()
+    {
+        var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+        var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+        Option<MediaItem> peek = enumerator.Peek(2);
+
+        enumerator.MoveNext();
+        enumerator.MoveNext();
+        Option<MediaItem> next = enumerator.Current;
+
+        peek.IsSome.Should().BeTrue();
+        next.IsSome.Should().BeTrue();
+        peek.ValueUnsafe().Id.Should().Be(3);
+        next.ValueUnsafe().Id.Should().Be(3);
+    }
+        
+    [Test]
+    public void Peek_Three_Should_Match_NextNextNext()
+    {
+        var state = new CollectionEnumeratorState { Index = 0, Seed = 0 };
+        var enumerator = new ShuffledMediaCollectionEnumerator(_mediaItems, state);
+
+        Option<MediaItem> peek = enumerator.Peek(3);
+
+        enumerator.MoveNext();
+        enumerator.MoveNext();
+        enumerator.MoveNext();
+        Option<MediaItem> next = enumerator.Current;
+
+        peek.IsSome.Should().BeTrue();
+        next.IsSome.Should().BeTrue();
+        peek.ValueUnsafe().Id.Should().Be(2);
+        next.ValueUnsafe().Id.Should().Be(2);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/BaseError.cs b/ErsatzTV.Core/BaseError.cs
index b3d3c105c..5e540cdf6 100644
--- a/ErsatzTV.Core/BaseError.cs
+++ b/ErsatzTV.Core/BaseError.cs
@@ -1,18 +1,15 @@
-using LanguageExt;
+namespace ErsatzTV.Core;
 
-namespace ErsatzTV.Core
+public class BaseError : NewType<BaseError, string>
 {
-    public class BaseError : NewType<BaseError, string>
+    public BaseError(string value) : base(value)
     {
-        public BaseError(string value) : base(value)
-        {
-        }
-
-        public static implicit operator BaseError(string str) => New(str);
     }
 
-    public static class ErrorExtensions
-    {
-        public static BaseError Join(this Seq<BaseError> errors) => string.Join("; ", errors);
-    }
+    public static implicit operator BaseError(string str) => New(str);
 }
+
+public static class ErrorExtensions
+{
+    public static BaseError Join(this Seq<BaseError> errors) => string.Join("; ", errors);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Channel.cs b/ErsatzTV.Core/Domain/Channel.cs
index 13b78ba57..8c80e3030 100644
--- a/ErsatzTV.Core/Domain/Channel.cs
+++ b/ErsatzTV.Core/Domain/Channel.cs
@@ -1,29 +1,26 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Domain.Filler;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Channel
 {
-    public class Channel
-    {
-        public static string NumberValidator = @"^[0-9]+(\.[0-9])?$";
+    public static string NumberValidator = @"^[0-9]+(\.[0-9])?$";
 
-        public Channel(Guid uniqueId) => UniqueId = uniqueId;
-        public int Id { get; set; }
-        public Guid UniqueId { get; init; }
-        public string Number { get; set; }
-        public string Name { get; set; }
-        public string Group { get; set; }
-        public string Categories { get; set; }
-        public int FFmpegProfileId { get; set; }
-        public FFmpegProfile FFmpegProfile { get; set; }
-        public int? WatermarkId { get; set; }
-        public ChannelWatermark Watermark { get; set; }
-        public int? FallbackFillerId { get; set; }
-        public FillerPreset FallbackFiller { get; set; }
-        public StreamingMode StreamingMode { get; set; }
-        public List<Playout> Playouts { get; set; }
-        public List<Artwork> Artwork { get; set; }
-        public string PreferredLanguageCode { get; set; }
-    }
-}
+    public Channel(Guid uniqueId) => UniqueId = uniqueId;
+    public int Id { get; set; }
+    public Guid UniqueId { get; init; }
+    public string Number { get; set; }
+    public string Name { get; set; }
+    public string Group { get; set; }
+    public string Categories { get; set; }
+    public int FFmpegProfileId { get; set; }
+    public FFmpegProfile FFmpegProfile { get; set; }
+    public int? WatermarkId { get; set; }
+    public ChannelWatermark Watermark { get; set; }
+    public int? FallbackFillerId { get; set; }
+    public FillerPreset FallbackFiller { get; set; }
+    public StreamingMode StreamingMode { get; set; }
+    public List<Playout> Playouts { get; set; }
+    public List<Artwork> Artwork { get; set; }
+    public string PreferredLanguageCode { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ChannelWatermark.cs b/ErsatzTV.Core/Domain/ChannelWatermark.cs
index 4a94ae328..6f56ce3dd 100644
--- a/ErsatzTV.Core/Domain/ChannelWatermark.cs
+++ b/ErsatzTV.Core/Domain/ChannelWatermark.cs
@@ -1,34 +1,33 @@
 using ErsatzTV.FFmpeg.State;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class ChannelWatermark
 {
-    public class ChannelWatermark
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public ChannelWatermarkMode Mode { get; set; }
-        public ChannelWatermarkImageSource ImageSource { get; set; }
-        public string Image { get; set; }
-        public WatermarkLocation Location { get; set; }
-        public WatermarkSize Size { get; set; }
-        public int WidthPercent { get; set; }
-        public int HorizontalMarginPercent { get; set; }
-        public int VerticalMarginPercent { get; set; }
-        public int FrequencyMinutes { get; set; }
-        public int DurationSeconds { get; set; }
-        public int Opacity { get; set; }
-    }
-
-    public enum ChannelWatermarkMode
-    {
-        None = 0,
-        Permanent = 1,
-        Intermittent = 2
-    }
-
-    public enum ChannelWatermarkImageSource
-    {
-        Custom = 0,
-        ChannelLogo = 1
-    }
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public ChannelWatermarkMode Mode { get; set; }
+    public ChannelWatermarkImageSource ImageSource { get; set; }
+    public string Image { get; set; }
+    public WatermarkLocation Location { get; set; }
+    public WatermarkSize Size { get; set; }
+    public int WidthPercent { get; set; }
+    public int HorizontalMarginPercent { get; set; }
+    public int VerticalMarginPercent { get; set; }
+    public int FrequencyMinutes { get; set; }
+    public int DurationSeconds { get; set; }
+    public int Opacity { get; set; }
 }
+
+public enum ChannelWatermarkMode
+{
+    None = 0,
+    Permanent = 1,
+    Intermittent = 2
+}
+
+public enum ChannelWatermarkImageSource
+{
+    Custom = 0,
+    ChannelLogo = 1
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/Collection.cs b/ErsatzTV.Core/Domain/Collection/Collection.cs
index 19e0ddebb..5dbdb5674 100644
--- a/ErsatzTV.Core/Domain/Collection/Collection.cs
+++ b/ErsatzTV.Core/Domain/Collection/Collection.cs
@@ -1,15 +1,12 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Collection
 {
-    public class Collection
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public bool UseCustomPlaybackOrder { get; set; }
-        public List<MediaItem> MediaItems { get; set; }
-        public List<CollectionItem> CollectionItems { get; set; }
-        public List<MultiCollection> MultiCollections { get; set; }
-        public List<MultiCollectionItem> MultiCollectionItems { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public bool UseCustomPlaybackOrder { get; set; }
+    public List<MediaItem> MediaItems { get; set; }
+    public List<CollectionItem> CollectionItems { get; set; }
+    public List<MultiCollection> MultiCollections { get; set; }
+    public List<MultiCollectionItem> MultiCollectionItems { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/CollectionItem.cs b/ErsatzTV.Core/Domain/Collection/CollectionItem.cs
index af1d04ea7..c66ce687f 100644
--- a/ErsatzTV.Core/Domain/Collection/CollectionItem.cs
+++ b/ErsatzTV.Core/Domain/Collection/CollectionItem.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class CollectionItem
 {
-    public class CollectionItem
-    {
-        public int CollectionId { get; set; }
-        public Collection Collection { get; set; }
-        public int MediaItemId { get; set; }
-        public MediaItem MediaItem { get; set; }
-        public int? CustomIndex { get; set; }
-    }
-}
+    public int CollectionId { get; set; }
+    public Collection Collection { get; set; }
+    public int MediaItemId { get; set; }
+    public MediaItem MediaItem { get; set; }
+    public int? CustomIndex { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/MultiCollection.cs b/ErsatzTV.Core/Domain/Collection/MultiCollection.cs
index dffee695a..ecfab3066 100644
--- a/ErsatzTV.Core/Domain/Collection/MultiCollection.cs
+++ b/ErsatzTV.Core/Domain/Collection/MultiCollection.cs
@@ -1,14 +1,11 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class MultiCollection
 {
-    public class MultiCollection
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public List<Collection> Collections { get; set; }
-        public List<SmartCollection> SmartCollections { get; set; }
-        public List<MultiCollectionItem> MultiCollectionItems { get; set; }
-        public List<MultiCollectionSmartItem> MultiCollectionSmartItems { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public List<Collection> Collections { get; set; }
+    public List<SmartCollection> SmartCollections { get; set; }
+    public List<MultiCollectionItem> MultiCollectionItems { get; set; }
+    public List<MultiCollectionSmartItem> MultiCollectionSmartItems { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/MultiCollectionItem.cs b/ErsatzTV.Core/Domain/Collection/MultiCollectionItem.cs
index e1a88884c..ce2428992 100644
--- a/ErsatzTV.Core/Domain/Collection/MultiCollectionItem.cs
+++ b/ErsatzTV.Core/Domain/Collection/MultiCollectionItem.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class MultiCollectionItem
 {
-    public class MultiCollectionItem
-    {
-        public int MultiCollectionId { get; set; }
-        public MultiCollection MultiCollection { get; set; }
-        public int CollectionId { get; set; }
-        public Collection Collection { get; set; }
-        public bool ScheduleAsGroup { get; set; }
-        public PlaybackOrder PlaybackOrder { get; set; }
-    }
-}
+    public int MultiCollectionId { get; set; }
+    public MultiCollection MultiCollection { get; set; }
+    public int CollectionId { get; set; }
+    public Collection Collection { get; set; }
+    public bool ScheduleAsGroup { get; set; }
+    public PlaybackOrder PlaybackOrder { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/MultiCollectionSmartItem.cs b/ErsatzTV.Core/Domain/Collection/MultiCollectionSmartItem.cs
index 7b98b9f78..7315c4301 100644
--- a/ErsatzTV.Core/Domain/Collection/MultiCollectionSmartItem.cs
+++ b/ErsatzTV.Core/Domain/Collection/MultiCollectionSmartItem.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class MultiCollectionSmartItem
 {
-    public class MultiCollectionSmartItem
-    {
-        public int MultiCollectionId { get; set; }
-        public MultiCollection MultiCollection { get; set; }
-        public int SmartCollectionId { get; set; }
-        public SmartCollection SmartCollection { get; set; }
-        public bool ScheduleAsGroup { get; set; }
-        public PlaybackOrder PlaybackOrder { get; set; }
-    }
-}
+    public int MultiCollectionId { get; set; }
+    public MultiCollection MultiCollection { get; set; }
+    public int SmartCollectionId { get; set; }
+    public SmartCollection SmartCollection { get; set; }
+    public bool ScheduleAsGroup { get; set; }
+    public PlaybackOrder PlaybackOrder { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/SmartCollection.cs b/ErsatzTV.Core/Domain/Collection/SmartCollection.cs
index d4604408f..2c05997a7 100644
--- a/ErsatzTV.Core/Domain/Collection/SmartCollection.cs
+++ b/ErsatzTV.Core/Domain/Collection/SmartCollection.cs
@@ -1,13 +1,10 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class SmartCollection
 {
-    public class SmartCollection
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public string Query { get; set; }
-        public List<MultiCollection> MultiCollections { get; set; }
-        public List<MultiCollectionSmartItem> MultiCollectionSmartItems { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public string Query { get; set; }
+    public List<MultiCollection> MultiCollections { get; set; }
+    public List<MultiCollectionSmartItem> MultiCollectionSmartItems { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/TraktList.cs b/ErsatzTV.Core/Domain/Collection/TraktList.cs
index 5057a9841..d88881d28 100644
--- a/ErsatzTV.Core/Domain/Collection/TraktList.cs
+++ b/ErsatzTV.Core/Domain/Collection/TraktList.cs
@@ -1,16 +1,13 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class TraktList
 {
-    public class TraktList
-    {
-        public int Id { get; set; }
-        public int TraktId { get; set; }
-        public string User { get; set; }
-        public string List { get; set; }
-        public string Name { get; set; }
-        public string Description { get; set; }
-        public int ItemCount { get; set; }
-        public List<TraktListItem> Items { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public int TraktId { get; set; }
+    public string User { get; set; }
+    public string List { get; set; }
+    public string Name { get; set; }
+    public string Description { get; set; }
+    public int ItemCount { get; set; }
+    public List<TraktListItem> Items { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/TraktListItem.cs b/ErsatzTV.Core/Domain/Collection/TraktListItem.cs
index bf0d91c2d..ed6d76ef4 100644
--- a/ErsatzTV.Core/Domain/Collection/TraktListItem.cs
+++ b/ErsatzTV.Core/Domain/Collection/TraktListItem.cs
@@ -1,31 +1,28 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class TraktListItem
 {
-    public class TraktListItem
+    public int Id { get; set; }
+    public int TraktListId { get; set; }
+    public TraktList TraktList { get; set; }
+
+    public TraktListItemKind Kind { get; set; }
+    public int TraktId { get; set; }
+    public int Rank { get; set; }
+    public string Title { get; set; }
+    public int? Year { get; set; }
+    public int? Season { get; set; }
+    public int? Episode { get; set; }
+    public List<TraktListItemGuid> Guids { get; set; }
+
+    public int? MediaItemId { get; set; }
+    public MediaItem MediaItem { get; set; }
+
+    public string DisplayTitle => Kind switch
     {
-        public int Id { get; set; }
-        public int TraktListId { get; set; }
-        public TraktList TraktList { get; set; }
-
-        public TraktListItemKind Kind { get; set; }
-        public int TraktId { get; set; }
-        public int Rank { get; set; }
-        public string Title { get; set; }
-        public int? Year { get; set; }
-        public int? Season { get; set; }
-        public int? Episode { get; set; }
-        public List<TraktListItemGuid> Guids { get; set; }
-
-        public int? MediaItemId { get; set; }
-        public MediaItem MediaItem { get; set; }
-
-        public string DisplayTitle => Kind switch
-        {
-            TraktListItemKind.Movie => $"{Title} ({Year})",
-            TraktListItemKind.Show => $"{Title} ({Year})",
-            TraktListItemKind.Season => $"{Title} ({Year}) S{Season:00}",
-            _ => $"{Title} ({Year}) S{Season:00}E{Episode:00}"
-        };
-    }
-}
+        TraktListItemKind.Movie => $"{Title} ({Year})",
+        TraktListItemKind.Show => $"{Title} ({Year})",
+        TraktListItemKind.Season => $"{Title} ({Year}) S{Season:00}",
+        _ => $"{Title} ({Year}) S{Season:00}E{Episode:00}"
+    };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/TraktListItemGuid.cs b/ErsatzTV.Core/Domain/Collection/TraktListItemGuid.cs
index d5652d8af..a60007157 100644
--- a/ErsatzTV.Core/Domain/Collection/TraktListItemGuid.cs
+++ b/ErsatzTV.Core/Domain/Collection/TraktListItemGuid.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class TraktListItemGuid
 {
-    public class TraktListItemGuid
-    {
-        public int Id { get; set; }
-        public string Guid { get; set; }
-        public int TraktListItemId { get; set; }
-        public TraktListItem TraktListItem { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Guid { get; set; }
+    public int TraktListItemId { get; set; }
+    public TraktListItem TraktListItem { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Collection/TraktListItemKind.cs b/ErsatzTV.Core/Domain/Collection/TraktListItemKind.cs
index 8a304694b..1c2d6035d 100644
--- a/ErsatzTV.Core/Domain/Collection/TraktListItemKind.cs
+++ b/ErsatzTV.Core/Domain/Collection/TraktListItemKind.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum TraktListItemKind
 {
-    public enum TraktListItemKind
-    {
-        Movie,
-        Show,
-        Season,
-        Episode
-    }
-}
+    Movie,
+    Show,
+    Season,
+    Episode
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/CollectionEnumeratorState.cs b/ErsatzTV.Core/Domain/CollectionEnumeratorState.cs
index 9f843f193..5740d7c58 100644
--- a/ErsatzTV.Core/Domain/CollectionEnumeratorState.cs
+++ b/ErsatzTV.Core/Domain/CollectionEnumeratorState.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class CollectionEnumeratorState
 {
-    public class CollectionEnumeratorState
-    {
-        public int Seed { get; set; }
-        public int Index { get; set; }
-    }
-}
+    public int Seed { get; set; }
+    public int Index { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ConfigElement.cs b/ErsatzTV.Core/Domain/ConfigElement.cs
index b410b55c0..258f21a66 100644
--- a/ErsatzTV.Core/Domain/ConfigElement.cs
+++ b/ErsatzTV.Core/Domain/ConfigElement.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class ConfigElement
 {
-    public class ConfigElement
-    {
-        public int Id { get; set; }
-        public string Key { get; set; }
-        public string Value { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Key { get; set; }
+    public string Value { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ConfigElementKey.cs b/ErsatzTV.Core/Domain/ConfigElementKey.cs
index f1e97145e..34c5f72a9 100644
--- a/ErsatzTV.Core/Domain/ConfigElementKey.cs
+++ b/ErsatzTV.Core/Domain/ConfigElementKey.cs
@@ -1,38 +1,37 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class ConfigElementKey
 {
-    public class ConfigElementKey
-    {
-        private ConfigElementKey(string key) => Key = key;
+    private ConfigElementKey(string key) => Key = key;
 
-        public string Key { get; }
+    public string Key { get; }
 
-        public static ConfigElementKey FFmpegPath => new("ffmpeg.ffmpeg_path");
-        public static ConfigElementKey FFprobePath => new("ffmpeg.ffprobe_path");
-        public static ConfigElementKey FFmpegDefaultProfileId => new("ffmpeg.default_profile_id");
-        public static ConfigElementKey FFmpegDefaultResolutionId => new("ffmpeg.default_resolution_id");
-        public static ConfigElementKey FFmpegSaveReports => new("ffmpeg.save_reports");
-        public static ConfigElementKey FFmpegPreferredLanguageCode => new("ffmpeg.preferred_language_code");
-        public static ConfigElementKey FFmpegGlobalWatermarkId => new("ffmpeg.global_watermark_id");
-        public static ConfigElementKey FFmpegGlobalFallbackFillerId => new("ffmpeg.global_fallback_filler_id");
-        public static ConfigElementKey FFmpegSegmenterTimeout => new("ffmpeg.segmenter.timeout_seconds");
-        public static ConfigElementKey FFmpegWorkAheadSegmenters => new("ffmpeg.segmenter.work_ahead_limit");
-        public static ConfigElementKey FFmpegInitialSegmentCount => new("ffmpeg.segmenter.initial_segment_count");
-        public static ConfigElementKey FFmpegUseLegacyTranscoder => new("ffmpeg.use_legacy_transcoder");
-        public static ConfigElementKey SearchIndexVersion => new("search_index.version");
-        public static ConfigElementKey HDHRTunerCount => new("hdhr.tuner_count");
-        public static ConfigElementKey ChannelsPageSize => new("pages.channels.page_size");
-        public static ConfigElementKey CollectionsPageSize => new("pages.collections.page_size");
-        public static ConfigElementKey MultiCollectionsPageSize => new("pages.multi_collections.page_size");
-        public static ConfigElementKey SmartCollectionsPageSize => new("pages.smart_collections.page_size");
-        public static ConfigElementKey SchedulesPageSize => new("pages.schedules.page_size");
-        public static ConfigElementKey SchedulesDetailPageSize => new("pages.schedules.detail_page_size");
-        public static ConfigElementKey PlayoutsPageSize => new("pages.playouts.page_size");
-        public static ConfigElementKey PlayoutsDetailPageSize => new("pages.playouts.detail_page_size");
-        public static ConfigElementKey PlayoutsDetailShowFiller => new("pages.playouts.detail_show_filler");
-        public static ConfigElementKey LogsPageSize => new("pages.logs.page_size");
-        public static ConfigElementKey TraktListsPageSize => new("pages.trakt.lists_page_size");
-        public static ConfigElementKey FillerPresetsPageSize => new("pages.filler_presets.page_size");
-        public static ConfigElementKey LibraryRefreshInterval => new("scanner.library_refresh_interval");
-        public static ConfigElementKey PlayoutDaysToBuild => new("playout.days_to_build");
-    }
-}
+    public static ConfigElementKey FFmpegPath => new("ffmpeg.ffmpeg_path");
+    public static ConfigElementKey FFprobePath => new("ffmpeg.ffprobe_path");
+    public static ConfigElementKey FFmpegDefaultProfileId => new("ffmpeg.default_profile_id");
+    public static ConfigElementKey FFmpegDefaultResolutionId => new("ffmpeg.default_resolution_id");
+    public static ConfigElementKey FFmpegSaveReports => new("ffmpeg.save_reports");
+    public static ConfigElementKey FFmpegPreferredLanguageCode => new("ffmpeg.preferred_language_code");
+    public static ConfigElementKey FFmpegGlobalWatermarkId => new("ffmpeg.global_watermark_id");
+    public static ConfigElementKey FFmpegGlobalFallbackFillerId => new("ffmpeg.global_fallback_filler_id");
+    public static ConfigElementKey FFmpegSegmenterTimeout => new("ffmpeg.segmenter.timeout_seconds");
+    public static ConfigElementKey FFmpegWorkAheadSegmenters => new("ffmpeg.segmenter.work_ahead_limit");
+    public static ConfigElementKey FFmpegInitialSegmentCount => new("ffmpeg.segmenter.initial_segment_count");
+    public static ConfigElementKey FFmpegUseLegacyTranscoder => new("ffmpeg.use_legacy_transcoder");
+    public static ConfigElementKey SearchIndexVersion => new("search_index.version");
+    public static ConfigElementKey HDHRTunerCount => new("hdhr.tuner_count");
+    public static ConfigElementKey ChannelsPageSize => new("pages.channels.page_size");
+    public static ConfigElementKey CollectionsPageSize => new("pages.collections.page_size");
+    public static ConfigElementKey MultiCollectionsPageSize => new("pages.multi_collections.page_size");
+    public static ConfigElementKey SmartCollectionsPageSize => new("pages.smart_collections.page_size");
+    public static ConfigElementKey SchedulesPageSize => new("pages.schedules.page_size");
+    public static ConfigElementKey SchedulesDetailPageSize => new("pages.schedules.detail_page_size");
+    public static ConfigElementKey PlayoutsPageSize => new("pages.playouts.page_size");
+    public static ConfigElementKey PlayoutsDetailPageSize => new("pages.playouts.detail_page_size");
+    public static ConfigElementKey PlayoutsDetailShowFiller => new("pages.playouts.detail_show_filler");
+    public static ConfigElementKey LogsPageSize => new("pages.logs.page_size");
+    public static ConfigElementKey TraktListsPageSize => new("pages.trakt.lists_page_size");
+    public static ConfigElementKey FillerPresetsPageSize => new("pages.filler_presets.page_size");
+    public static ConfigElementKey LibraryRefreshInterval => new("scanner.library_refresh_interval");
+    public static ConfigElementKey PlayoutDaysToBuild => new("playout.days_to_build");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/FFmpegProfile.cs b/ErsatzTV.Core/Domain/FFmpegProfile.cs
index e13025d37..4072b5083 100644
--- a/ErsatzTV.Core/Domain/FFmpegProfile.cs
+++ b/ErsatzTV.Core/Domain/FFmpegProfile.cs
@@ -1,51 +1,50 @@
 using ErsatzTV.Core.FFmpeg;
 
-namespace ErsatzTV.Core.Domain
-{
-    public record FFmpegProfile
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public int ThreadCount { get; set; }
-        public bool Transcode { get; set; }
-        public HardwareAccelerationKind HardwareAcceleration { get; set; }
-        public VaapiDriver VaapiDriver { get; set; }
-        public string VaapiDevice { get; set; }
-        public int ResolutionId { get; set; }
-        public Resolution Resolution { get; set; }
-        public string VideoCodec { get; set; }
-        public bool NormalizeVideo { get; set; }
-        public int VideoBitrate { get; set; }
-        public int VideoBufferSize { get; set; }
-        public string AudioCodec { get; set; }
-        public int AudioBitrate { get; set; }
-        public int AudioBufferSize { get; set; }
-        public bool NormalizeLoudness { get; set; }
-        public int AudioChannels { get; set; }
-        public int AudioSampleRate { get; set; }
-        public bool NormalizeAudio { get; set; }
-        public bool NormalizeFramerate { get; set; }
+namespace ErsatzTV.Core.Domain;
 
-        public static FFmpegProfile New(string name, Resolution resolution) =>
-            new()
-            {
-                Name = name,
-                ThreadCount = 0,
-                Transcode = true,
-                ResolutionId = resolution.Id,
-                Resolution = resolution,
-                VideoCodec = "libx264",
-                AudioCodec = "ac3",
-                VideoBitrate = 2000,
-                VideoBufferSize = 4000,
-                AudioBitrate = 192,
-                AudioBufferSize = 384,
-                NormalizeLoudness = true,
-                AudioChannels = 2,
-                AudioSampleRate = 48,
-                NormalizeVideo = true,
-                NormalizeAudio = true,
-                HardwareAcceleration = HardwareAccelerationKind.None
-            };
-    }
-}
+public record FFmpegProfile
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public int ThreadCount { get; set; }
+    public bool Transcode { get; set; }
+    public HardwareAccelerationKind HardwareAcceleration { get; set; }
+    public VaapiDriver VaapiDriver { get; set; }
+    public string VaapiDevice { get; set; }
+    public int ResolutionId { get; set; }
+    public Resolution Resolution { get; set; }
+    public string VideoCodec { get; set; }
+    public bool NormalizeVideo { get; set; }
+    public int VideoBitrate { get; set; }
+    public int VideoBufferSize { get; set; }
+    public string AudioCodec { get; set; }
+    public int AudioBitrate { get; set; }
+    public int AudioBufferSize { get; set; }
+    public bool NormalizeLoudness { get; set; }
+    public int AudioChannels { get; set; }
+    public int AudioSampleRate { get; set; }
+    public bool NormalizeAudio { get; set; }
+    public bool NormalizeFramerate { get; set; }
+
+    public static FFmpegProfile New(string name, Resolution resolution) =>
+        new()
+        {
+            Name = name,
+            ThreadCount = 0,
+            Transcode = true,
+            ResolutionId = resolution.Id,
+            Resolution = resolution,
+            VideoCodec = "libx264",
+            AudioCodec = "ac3",
+            VideoBitrate = 2000,
+            VideoBufferSize = 4000,
+            AudioBitrate = 192,
+            AudioBufferSize = 384,
+            NormalizeLoudness = true,
+            AudioChannels = 2,
+            AudioSampleRate = 48,
+            NormalizeVideo = true,
+            NormalizeAudio = true,
+            HardwareAcceleration = HardwareAccelerationKind.None
+        };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Filler/FillerKind.cs b/ErsatzTV.Core/Domain/Filler/FillerKind.cs
index 2d2242a4b..7f140b20f 100644
--- a/ErsatzTV.Core/Domain/Filler/FillerKind.cs
+++ b/ErsatzTV.Core/Domain/Filler/FillerKind.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Domain.Filler
+namespace ErsatzTV.Core.Domain.Filler;
+
+public enum FillerKind
 {
-    public enum FillerKind
-    {
-        None = 0,
-        PreRoll = 1,
-        MidRoll = 2,
-        PostRoll = 3,
-        Tail = 4,
-        Fallback = 5
-    }
-}
+    None = 0,
+    PreRoll = 1,
+    MidRoll = 2,
+    PostRoll = 3,
+    Tail = 4,
+    Fallback = 5
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Filler/FillerMode.cs b/ErsatzTV.Core/Domain/Filler/FillerMode.cs
index b9360667d..7a086c93a 100644
--- a/ErsatzTV.Core/Domain/Filler/FillerMode.cs
+++ b/ErsatzTV.Core/Domain/Filler/FillerMode.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain.Filler
+namespace ErsatzTV.Core.Domain.Filler;
+
+public enum FillerMode
 {
-    public enum FillerMode
-    {
-        None = 0,
-        Duration = 1,
-        Count = 2,
-        Pad = 3
-    }
-}
+    None = 0,
+    Duration = 1,
+    Count = 2,
+    Pad = 3
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Filler/FillerPreset.cs b/ErsatzTV.Core/Domain/Filler/FillerPreset.cs
index 84565a212..542c54532 100644
--- a/ErsatzTV.Core/Domain/Filler/FillerPreset.cs
+++ b/ErsatzTV.Core/Domain/Filler/FillerPreset.cs
@@ -1,24 +1,21 @@
-using System;
+namespace ErsatzTV.Core.Domain.Filler;
 
-namespace ErsatzTV.Core.Domain.Filler
+public class FillerPreset
 {
-    public class FillerPreset
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public FillerKind FillerKind { get; set; }
-        public FillerMode FillerMode { get; set; }
-        public TimeSpan? Duration { get; set; }
-        public int? Count { get; set; }
-        public int? PadToNearestMinute { get; set; }
-        public ProgramScheduleItemCollectionType CollectionType { get; set; }
-        public int? CollectionId { get; set; }
-        public Collection Collection { get; set; }
-        public int? MediaItemId { get; set; }
-        public MediaItem MediaItem { get; set; }
-        public int? MultiCollectionId { get; set; }
-        public MultiCollection MultiCollection { get; set; }
-        public int? SmartCollectionId { get; set; }
-        public SmartCollection SmartCollection { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public FillerKind FillerKind { get; set; }
+    public FillerMode FillerMode { get; set; }
+    public TimeSpan? Duration { get; set; }
+    public int? Count { get; set; }
+    public int? PadToNearestMinute { get; set; }
+    public ProgramScheduleItemCollectionType CollectionType { get; set; }
+    public int? CollectionId { get; set; }
+    public Collection Collection { get; set; }
+    public int? MediaItemId { get; set; }
+    public MediaItem MediaItem { get; set; }
+    public int? MultiCollectionId { get; set; }
+    public MultiCollection MultiCollection { get; set; }
+    public int? SmartCollectionId { get; set; }
+    public SmartCollection SmartCollection { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/GuideMode.cs b/ErsatzTV.Core/Domain/GuideMode.cs
index d3c4265ab..4c800e8ab 100644
--- a/ErsatzTV.Core/Domain/GuideMode.cs
+++ b/ErsatzTV.Core/Domain/GuideMode.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum GuideMode
 {
-    public enum GuideMode
-    {
-        Normal = 0,
-        Filler = 1
-    }
-}
+    Normal = 0,
+    Filler = 1
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/HardwareAccelerationKind.cs b/ErsatzTV.Core/Domain/HardwareAccelerationKind.cs
index b63b223e5..c987b464e 100644
--- a/ErsatzTV.Core/Domain/HardwareAccelerationKind.cs
+++ b/ErsatzTV.Core/Domain/HardwareAccelerationKind.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum HardwareAccelerationKind
 {
-    public enum HardwareAccelerationKind
-    {
-        None = 0,
-        Qsv = 1,
-        Nvenc = 2,
-        Vaapi = 3,
-        VideoToolbox = 4
-    }
-}
+    None = 0,
+    Qsv = 1,
+    Nvenc = 2,
+    Vaapi = 3,
+    VideoToolbox = 4
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/LanguageCode.cs b/ErsatzTV.Core/Domain/LanguageCode.cs
index f9411631a..3bd52ead5 100644
--- a/ErsatzTV.Core/Domain/LanguageCode.cs
+++ b/ErsatzTV.Core/Domain/LanguageCode.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class LanguageCode
 {
-    public class LanguageCode
-    {
-        public int Id { get; set; }
-        public string ThreeCode1 { get; set; }
-        public string ThreeCode2 { get; set; }
-        public string TwoCode { get; set; }
-        public string EnglishName { get; set; }
-        public string FrenchName { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string ThreeCode1 { get; set; }
+    public string ThreeCode2 { get; set; }
+    public string TwoCode { get; set; }
+    public string EnglishName { get; set; }
+    public string FrenchName { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Library/EmbyLibrary.cs b/ErsatzTV.Core/Domain/Library/EmbyLibrary.cs
index 13622f29b..c4b55d4a2 100644
--- a/ErsatzTV.Core/Domain/Library/EmbyLibrary.cs
+++ b/ErsatzTV.Core/Domain/Library/EmbyLibrary.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class EmbyLibrary : Library
 {
-    public class EmbyLibrary : Library
-    {
-        public string ItemId { get; set; }
-        public bool ShouldSyncItems { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public bool ShouldSyncItems { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Library/JellyfinLibrary.cs b/ErsatzTV.Core/Domain/Library/JellyfinLibrary.cs
index 23d8e5aeb..a7729edcf 100644
--- a/ErsatzTV.Core/Domain/Library/JellyfinLibrary.cs
+++ b/ErsatzTV.Core/Domain/Library/JellyfinLibrary.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class JellyfinLibrary : Library
 {
-    public class JellyfinLibrary : Library
-    {
-        public string ItemId { get; set; }
-        public bool ShouldSyncItems { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public bool ShouldSyncItems { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Library/Library.cs b/ErsatzTV.Core/Domain/Library/Library.cs
index 5344357bb..1b447d724 100644
--- a/ErsatzTV.Core/Domain/Library/Library.cs
+++ b/ErsatzTV.Core/Domain/Library/Library.cs
@@ -1,18 +1,14 @@
-using System;
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public abstract class Library
 {
-    public abstract class Library
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public LibraryMediaKind MediaKind { get; set; }
-        public DateTime? LastScan { get; set; }
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public LibraryMediaKind MediaKind { get; set; }
+    public DateTime? LastScan { get; set; }
 
-        public int MediaSourceId { get; set; }
-        public MediaSource MediaSource { get; set; }
+    public int MediaSourceId { get; set; }
+    public MediaSource MediaSource { get; set; }
 
-        public List<LibraryPath> Paths { get; set; }
-    }
-}
+    public List<LibraryPath> Paths { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Library/LibraryFolder.cs b/ErsatzTV.Core/Domain/Library/LibraryFolder.cs
index 6860ba3a4..8c37aeb43 100644
--- a/ErsatzTV.Core/Domain/Library/LibraryFolder.cs
+++ b/ErsatzTV.Core/Domain/Library/LibraryFolder.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class LibraryFolder
 {
-    public class LibraryFolder
-    {
-        public int Id { get; set; }
-        public string Path { get; set; }
-        public int LibraryPathId { get; set; }
-        public LibraryPath LibraryPath { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Path { get; set; }
+    public int LibraryPathId { get; set; }
+    public LibraryPath LibraryPath { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Library/LibraryMediaKind.cs b/ErsatzTV.Core/Domain/Library/LibraryMediaKind.cs
index dc55f45e9..7b36cd9f1 100644
--- a/ErsatzTV.Core/Domain/Library/LibraryMediaKind.cs
+++ b/ErsatzTV.Core/Domain/Library/LibraryMediaKind.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum LibraryMediaKind
 {
-    public enum LibraryMediaKind
-    {
-        Movies = 1,
-        Shows = 2,
-        MusicVideos = 3,
-        OtherVideos = 4,
-        Songs = 5
-    }
-}
+    Movies = 1,
+    Shows = 2,
+    MusicVideos = 3,
+    OtherVideos = 4,
+    Songs = 5
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Library/LibraryPath.cs b/ErsatzTV.Core/Domain/Library/LibraryPath.cs
index 291d62004..060e75f1a 100644
--- a/ErsatzTV.Core/Domain/Library/LibraryPath.cs
+++ b/ErsatzTV.Core/Domain/Library/LibraryPath.cs
@@ -1,18 +1,14 @@
-using System;
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class LibraryPath
 {
-    public class LibraryPath
-    {
-        public int Id { get; set; }
-        public string Path { get; set; }
-        public DateTime? LastScan { get; set; }
+    public int Id { get; set; }
+    public string Path { get; set; }
+    public DateTime? LastScan { get; set; }
 
-        public int LibraryId { get; set; }
-        public Library Library { get; set; }
+    public int LibraryId { get; set; }
+    public Library Library { get; set; }
 
-        public List<MediaItem> MediaItems { get; set; }
-        public List<LibraryFolder> LibraryFolders { get; set; }
-    }
-}
+    public List<MediaItem> MediaItems { get; set; }
+    public List<LibraryFolder> LibraryFolders { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Library/LocalLibrary.cs b/ErsatzTV.Core/Domain/Library/LocalLibrary.cs
index 787f0df50..1213f9ea7 100644
--- a/ErsatzTV.Core/Domain/Library/LocalLibrary.cs
+++ b/ErsatzTV.Core/Domain/Library/LocalLibrary.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class LocalLibrary : Library
 {
-    public class LocalLibrary : Library
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Library/PlexLibrary.cs b/ErsatzTV.Core/Domain/Library/PlexLibrary.cs
index bbd35c13e..acf403d7c 100644
--- a/ErsatzTV.Core/Domain/Library/PlexLibrary.cs
+++ b/ErsatzTV.Core/Domain/Library/PlexLibrary.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlexLibrary : Library
 {
-    public class PlexLibrary : Library
-    {
-        public string Key { get; set; }
-        public bool ShouldSyncItems { get; set; }
-    }
-}
+    public string Key { get; set; }
+    public bool ShouldSyncItems { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/LogEntry.cs b/ErsatzTV.Core/Domain/LogEntry.cs
index 6685e8341..1d29ea975 100644
--- a/ErsatzTV.Core/Domain/LogEntry.cs
+++ b/ErsatzTV.Core/Domain/LogEntry.cs
@@ -1,12 +1,9 @@
-using System;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
-{
-    public record LogEntry(
-        int Id,
-        DateTime Timestamp,
-        string Level,
-        string Exception,
-        string RenderedMessage,
-        string Properties);
-}
+public record LogEntry(
+    int Id,
+    DateTime Timestamp,
+    string Level,
+    string Exception,
+    string RenderedMessage,
+    string Properties);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/Artist.cs b/ErsatzTV.Core/Domain/MediaItem/Artist.cs
index c30cc2d2a..d16a6e1ed 100644
--- a/ErsatzTV.Core/Domain/MediaItem/Artist.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/Artist.cs
@@ -1,10 +1,7 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Artist : MediaItem
 {
-    public class Artist : MediaItem
-    {
-        public List<MusicVideo> MusicVideos { get; set; }
-        public List<ArtistMetadata> ArtistMetadata { get; set; }
-    }
-}
+    public List<MusicVideo> MusicVideos { get; set; }
+    public List<ArtistMetadata> ArtistMetadata { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/BackgroundImageMediaVersion.cs b/ErsatzTV.Core/Domain/MediaItem/BackgroundImageMediaVersion.cs
index 480cfdd04..01ce6395b 100644
--- a/ErsatzTV.Core/Domain/MediaItem/BackgroundImageMediaVersion.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/BackgroundImageMediaVersion.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class BackgroundImageMediaVersion : MediaVersion
 {
-    public class BackgroundImageMediaVersion : MediaVersion
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/CoverArtMediaVersion.cs b/ErsatzTV.Core/Domain/MediaItem/CoverArtMediaVersion.cs
index 16d26ae6e..bcd1adcfa 100644
--- a/ErsatzTV.Core/Domain/MediaItem/CoverArtMediaVersion.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/CoverArtMediaVersion.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class CoverArtMediaVersion : MediaVersion
 {
-    public class CoverArtMediaVersion : MediaVersion
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/EmbyEpisode.cs b/ErsatzTV.Core/Domain/MediaItem/EmbyEpisode.cs
index 482096070..dd25bcd1f 100644
--- a/ErsatzTV.Core/Domain/MediaItem/EmbyEpisode.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/EmbyEpisode.cs
@@ -1,11 +1,10 @@
 using System.Diagnostics;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+[DebuggerDisplay("{EpisodeMetadata[0].Title}")]
+public class EmbyEpisode : Episode
 {
-    [DebuggerDisplay("{EpisodeMetadata[0].Title}")]
-    public class EmbyEpisode : Episode
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/EmbyMovie.cs b/ErsatzTV.Core/Domain/MediaItem/EmbyMovie.cs
index a82b6b15b..4c888813c 100644
--- a/ErsatzTV.Core/Domain/MediaItem/EmbyMovie.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/EmbyMovie.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class EmbyMovie : Movie
 {
-    public class EmbyMovie : Movie
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/EmbySeason.cs b/ErsatzTV.Core/Domain/MediaItem/EmbySeason.cs
index cdd7e7039..07bb5f952 100644
--- a/ErsatzTV.Core/Domain/MediaItem/EmbySeason.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/EmbySeason.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class EmbySeason : Season
 {
-    public class EmbySeason : Season
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/EmbyShow.cs b/ErsatzTV.Core/Domain/MediaItem/EmbyShow.cs
index 0ba9dd3f0..15929b185 100644
--- a/ErsatzTV.Core/Domain/MediaItem/EmbyShow.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/EmbyShow.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class EmbyShow : Show
 {
-    public class EmbyShow : Show
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/Episode.cs b/ErsatzTV.Core/Domain/MediaItem/Episode.cs
index a7f36508b..d8ffbd794 100644
--- a/ErsatzTV.Core/Domain/MediaItem/Episode.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/Episode.cs
@@ -1,14 +1,12 @@
-using System.Collections.Generic;
-using System.Diagnostics;
+using System.Diagnostics;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+[DebuggerDisplay("{EpisodeMetadata[0].Title ?? \"[unknown episode]\"}")]
+public class Episode : MediaItem
 {
-    [DebuggerDisplay("{EpisodeMetadata[0].Title ?? \"[unknown episode]\"}")]
-    public class Episode : MediaItem
-    {
-        public int SeasonId { get; set; }
-        public Season Season { get; set; }
-        public List<EpisodeMetadata> EpisodeMetadata { get; set; }
-        public List<MediaVersion> MediaVersions { get; set; }
-    }
-}
+    public int SeasonId { get; set; }
+    public Season Season { get; set; }
+    public List<EpisodeMetadata> EpisodeMetadata { get; set; }
+    public List<MediaVersion> MediaVersions { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/FallbackMediaVersion.cs b/ErsatzTV.Core/Domain/MediaItem/FallbackMediaVersion.cs
index 56a543cfe..5c7824343 100644
--- a/ErsatzTV.Core/Domain/MediaItem/FallbackMediaVersion.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/FallbackMediaVersion.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class FallbackMediaVersion : MediaVersion
 {
-    public class FallbackMediaVersion : MediaVersion
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/JellyfinEpisode.cs b/ErsatzTV.Core/Domain/MediaItem/JellyfinEpisode.cs
index 5c755cf2d..b79b27a28 100644
--- a/ErsatzTV.Core/Domain/MediaItem/JellyfinEpisode.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/JellyfinEpisode.cs
@@ -1,11 +1,10 @@
 using System.Diagnostics;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+[DebuggerDisplay("{EpisodeMetadata[0].Title}")]
+public class JellyfinEpisode : Episode
 {
-    [DebuggerDisplay("{EpisodeMetadata[0].Title}")]
-    public class JellyfinEpisode : Episode
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/JellyfinMovie.cs b/ErsatzTV.Core/Domain/MediaItem/JellyfinMovie.cs
index cec2f238d..d5a955e97 100644
--- a/ErsatzTV.Core/Domain/MediaItem/JellyfinMovie.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/JellyfinMovie.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class JellyfinMovie : Movie
 {
-    public class JellyfinMovie : Movie
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/JellyfinSeason.cs b/ErsatzTV.Core/Domain/MediaItem/JellyfinSeason.cs
index c8f603fc6..7dda603ee 100644
--- a/ErsatzTV.Core/Domain/MediaItem/JellyfinSeason.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/JellyfinSeason.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class JellyfinSeason : Season
 {
-    public class JellyfinSeason : Season
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/JellyfinShow.cs b/ErsatzTV.Core/Domain/MediaItem/JellyfinShow.cs
index a6ae29d80..11d1b2233 100644
--- a/ErsatzTV.Core/Domain/MediaItem/JellyfinShow.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/JellyfinShow.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class JellyfinShow : Show
 {
-    public class JellyfinShow : Show
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/MediaChapter.cs b/ErsatzTV.Core/Domain/MediaItem/MediaChapter.cs
index 53560452f..566f366c9 100644
--- a/ErsatzTV.Core/Domain/MediaItem/MediaChapter.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/MediaChapter.cs
@@ -1,15 +1,12 @@
-using System;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class MediaChapter
 {
-    public class MediaChapter
-    {
-        public int Id { get; set; }
-        public int MediaVersionId { get; set; }
-        public MediaVersion MediaVersion { get; set; }
-        public long ChapterId { get; set; }
-        public TimeSpan StartTime { get; set; }
-        public TimeSpan EndTime { get; set; }
-        public string Title { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public int MediaVersionId { get; set; }
+    public MediaVersion MediaVersion { get; set; }
+    public long ChapterId { get; set; }
+    public TimeSpan StartTime { get; set; }
+    public TimeSpan EndTime { get; set; }
+    public string Title { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/MediaFile.cs b/ErsatzTV.Core/Domain/MediaItem/MediaFile.cs
index 5673ec66e..4f4413bc5 100644
--- a/ErsatzTV.Core/Domain/MediaItem/MediaFile.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/MediaFile.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
-{
-    public class MediaFile
-    {
-        public int Id { get; set; }
-        public string Path { get; set; }
+namespace ErsatzTV.Core.Domain;
 
-        public int MediaVersionId { get; set; }
-        public MediaVersion MediaVersion { get; set; }
-    }
-}
+public class MediaFile
+{
+    public int Id { get; set; }
+    public string Path { get; set; }
+
+    public int MediaVersionId { get; set; }
+    public MediaVersion MediaVersion { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/MediaItem.cs b/ErsatzTV.Core/Domain/MediaItem/MediaItem.cs
index b150ec0f9..85002d163 100644
--- a/ErsatzTV.Core/Domain/MediaItem/MediaItem.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/MediaItem.cs
@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-
-namespace ErsatzTV.Core.Domain;
+namespace ErsatzTV.Core.Domain;
 
 public class MediaItem
 {
diff --git a/ErsatzTV.Core/Domain/MediaItem/MediaStream.cs b/ErsatzTV.Core/Domain/MediaItem/MediaStream.cs
index 115b75587..4998ce3a2 100644
--- a/ErsatzTV.Core/Domain/MediaItem/MediaStream.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/MediaStream.cs
@@ -1,21 +1,20 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class MediaStream
 {
-    public class MediaStream
-    {
-        public int Id { get; set; }
-        public int Index { get; set; }
-        public string Codec { get; set; }
-        public string Profile { get; set; }
-        public MediaStreamKind MediaStreamKind { get; set; }
-        public string Language { get; set; }
-        public int Channels { get; set; }
-        public string Title { get; set; }
-        public bool Default { get; set; }
-        public bool Forced { get; set; }
-        public bool AttachedPic { get; set; }
-        public string PixelFormat { get; set; }
-        public int BitsPerRawSample { get; set; }
-        public int MediaVersionId { get; set; }
-        public MediaVersion MediaVersion { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public int Index { get; set; }
+    public string Codec { get; set; }
+    public string Profile { get; set; }
+    public MediaStreamKind MediaStreamKind { get; set; }
+    public string Language { get; set; }
+    public int Channels { get; set; }
+    public string Title { get; set; }
+    public bool Default { get; set; }
+    public bool Forced { get; set; }
+    public bool AttachedPic { get; set; }
+    public string PixelFormat { get; set; }
+    public int BitsPerRawSample { get; set; }
+    public int MediaVersionId { get; set; }
+    public MediaVersion MediaVersion { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/MediaStreamKind.cs b/ErsatzTV.Core/Domain/MediaItem/MediaStreamKind.cs
index bfee9b14b..eff7970ef 100644
--- a/ErsatzTV.Core/Domain/MediaItem/MediaStreamKind.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/MediaStreamKind.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum MediaStreamKind
 {
-    public enum MediaStreamKind
-    {
-        Video = 1,
-        Audio = 2,
-        Subtitle = 3
-    }
-}
+    Video = 1,
+    Audio = 2,
+    Subtitle = 3
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/MediaVersion.cs b/ErsatzTV.Core/Domain/MediaItem/MediaVersion.cs
index 4d77198ce..0a4455ea5 100644
--- a/ErsatzTV.Core/Domain/MediaItem/MediaVersion.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/MediaVersion.cs
@@ -1,24 +1,21 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class MediaVersion : IDisplaySize
 {
-    public class MediaVersion : IDisplaySize
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public List<MediaFile> MediaFiles { get; set; }
-        public List<MediaStream> Streams { get; set; }
-        public List<MediaChapter> Chapters { get; set; }
-        public TimeSpan Duration { get; set; }
-        public string SampleAspectRatio { get; set; }
-        public string DisplayAspectRatio { get; set; }
-        public string RFrameRate { get; set; }
-        public VideoScanKind VideoScanKind { get; set; }
-        public DateTime DateAdded { get; set; }
-        public DateTime DateUpdated { get; set; }
-        public int Width { get; set; }
-        public int Height { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public List<MediaFile> MediaFiles { get; set; }
+    public List<MediaStream> Streams { get; set; }
+    public List<MediaChapter> Chapters { get; set; }
+    public TimeSpan Duration { get; set; }
+    public string SampleAspectRatio { get; set; }
+    public string DisplayAspectRatio { get; set; }
+    public string RFrameRate { get; set; }
+    public VideoScanKind VideoScanKind { get; set; }
+    public DateTime DateAdded { get; set; }
+    public DateTime DateUpdated { get; set; }
+    public int Width { get; set; }
+    public int Height { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/Movie.cs b/ErsatzTV.Core/Domain/MediaItem/Movie.cs
index 39e1f3297..55da04a9e 100644
--- a/ErsatzTV.Core/Domain/MediaItem/Movie.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/Movie.cs
@@ -1,10 +1,7 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Movie : MediaItem
 {
-    public class Movie : MediaItem
-    {
-        public List<MovieMetadata> MovieMetadata { get; set; }
-        public List<MediaVersion> MediaVersions { get; set; }
-    }
-}
+    public List<MovieMetadata> MovieMetadata { get; set; }
+    public List<MediaVersion> MediaVersions { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/MusicVideo.cs b/ErsatzTV.Core/Domain/MediaItem/MusicVideo.cs
index ae105b8aa..e2c2234bd 100644
--- a/ErsatzTV.Core/Domain/MediaItem/MusicVideo.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/MusicVideo.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class MusicVideo : MediaItem
 {
-    public class MusicVideo : MediaItem
-    {
-        public int ArtistId { get; set; }
-        public Artist Artist { get; set; }
-        public List<MusicVideoMetadata> MusicVideoMetadata { get; set; }
-        public List<MediaVersion> MediaVersions { get; set; }
-    }
-}
+    public int ArtistId { get; set; }
+    public Artist Artist { get; set; }
+    public List<MusicVideoMetadata> MusicVideoMetadata { get; set; }
+    public List<MediaVersion> MediaVersions { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/OtherVideo.cs b/ErsatzTV.Core/Domain/MediaItem/OtherVideo.cs
index 5eb5fab36..775c801c9 100644
--- a/ErsatzTV.Core/Domain/MediaItem/OtherVideo.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/OtherVideo.cs
@@ -1,10 +1,7 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class OtherVideo : MediaItem
 {
-    public class OtherVideo : MediaItem
-    {
-        public List<OtherVideoMetadata> OtherVideoMetadata { get; set; }
-        public List<MediaVersion> MediaVersions { get; set; }
-    }
-}
+    public List<OtherVideoMetadata> OtherVideoMetadata { get; set; }
+    public List<MediaVersion> MediaVersions { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/PlexEpisode.cs b/ErsatzTV.Core/Domain/MediaItem/PlexEpisode.cs
index 604c273f2..fb53a5349 100644
--- a/ErsatzTV.Core/Domain/MediaItem/PlexEpisode.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/PlexEpisode.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlexEpisode : Episode
 {
-    public class PlexEpisode : Episode
-    {
-        public string Key { get; set; }
-    }
-}
+    public string Key { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/PlexMediaFile.cs b/ErsatzTV.Core/Domain/MediaItem/PlexMediaFile.cs
index ee902d82e..41010f8c1 100644
--- a/ErsatzTV.Core/Domain/MediaItem/PlexMediaFile.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/PlexMediaFile.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlexMediaFile : MediaFile
 {
-    public class PlexMediaFile : MediaFile
-    {
-        public int PlexId { get; set; }
-        public string Key { get; set; }
-    }
-}
+    public int PlexId { get; set; }
+    public string Key { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/PlexMovie.cs b/ErsatzTV.Core/Domain/MediaItem/PlexMovie.cs
index 37c100374..442e9917e 100644
--- a/ErsatzTV.Core/Domain/MediaItem/PlexMovie.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/PlexMovie.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlexMovie : Movie
 {
-    public class PlexMovie : Movie
-    {
-        public string Key { get; set; }
-    }
-}
+    public string Key { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/PlexSeason.cs b/ErsatzTV.Core/Domain/MediaItem/PlexSeason.cs
index a6faaeb48..244e60042 100644
--- a/ErsatzTV.Core/Domain/MediaItem/PlexSeason.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/PlexSeason.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlexSeason : Season
 {
-    public class PlexSeason : Season
-    {
-        public string Key { get; set; }
-    }
-}
+    public string Key { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/PlexShow.cs b/ErsatzTV.Core/Domain/MediaItem/PlexShow.cs
index 6d4041a78..f2f0de123 100644
--- a/ErsatzTV.Core/Domain/MediaItem/PlexShow.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/PlexShow.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlexShow : Show
 {
-    public class PlexShow : Show
-    {
-        public string Key { get; set; }
-    }
-}
+    public string Key { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/Season.cs b/ErsatzTV.Core/Domain/MediaItem/Season.cs
index 6eea46387..bc1819ddf 100644
--- a/ErsatzTV.Core/Domain/MediaItem/Season.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/Season.cs
@@ -1,14 +1,11 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Season : MediaItem
 {
-    public class Season : MediaItem
-    {
-        public int SeasonNumber { get; set; }
-        public int ShowId { get; set; }
-        public Show Show { get; set; }
+    public int SeasonNumber { get; set; }
+    public int ShowId { get; set; }
+    public Show Show { get; set; }
 
-        public List<Episode> Episodes { get; set; }
-        public List<SeasonMetadata> SeasonMetadata { get; set; }
-    }
-}
+    public List<Episode> Episodes { get; set; }
+    public List<SeasonMetadata> SeasonMetadata { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/Show.cs b/ErsatzTV.Core/Domain/MediaItem/Show.cs
index 230e6f3d3..4d9ed1a5a 100644
--- a/ErsatzTV.Core/Domain/MediaItem/Show.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/Show.cs
@@ -1,10 +1,7 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Show : MediaItem
 {
-    public class Show : MediaItem
-    {
-        public List<Season> Seasons { get; set; }
-        public List<ShowMetadata> ShowMetadata { get; set; }
-    }
-}
+    public List<Season> Seasons { get; set; }
+    public List<ShowMetadata> ShowMetadata { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/Song.cs b/ErsatzTV.Core/Domain/MediaItem/Song.cs
index b85357d8b..ae1db64ea 100644
--- a/ErsatzTV.Core/Domain/MediaItem/Song.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/Song.cs
@@ -1,10 +1,7 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Song : MediaItem
 {
-    public class Song : MediaItem
-    {
-        public List<SongMetadata> SongMetadata { get; set; }
-        public List<MediaVersion> MediaVersions { get; set; }
-    }
-}
+    public List<SongMetadata> SongMetadata { get; set; }
+    public List<MediaVersion> MediaVersions { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaItem/VideoScanKind.cs b/ErsatzTV.Core/Domain/MediaItem/VideoScanKind.cs
index 812061ac3..edd1012c6 100644
--- a/ErsatzTV.Core/Domain/MediaItem/VideoScanKind.cs
+++ b/ErsatzTV.Core/Domain/MediaItem/VideoScanKind.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum VideoScanKind
 {
-    public enum VideoScanKind
-    {
-        Unknown = 0,
-        Progressive = 1,
-        Interlaced = 2
-    }
-}
+    Unknown = 0,
+    Progressive = 1,
+    Interlaced = 2
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/EmbyConnection.cs b/ErsatzTV.Core/Domain/MediaSource/EmbyConnection.cs
index 77b6f1842..e38797d5b 100644
--- a/ErsatzTV.Core/Domain/MediaSource/EmbyConnection.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/EmbyConnection.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class EmbyConnection
 {
-    public class EmbyConnection
-    {
-        public int Id { get; set; }
-        public string Address { get; set; }
-        public int EmbyMediaSourceId { get; set; }
-        public EmbyMediaSource EmbyMediaSource { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Address { get; set; }
+    public int EmbyMediaSourceId { get; set; }
+    public EmbyMediaSource EmbyMediaSource { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/EmbyMediaSource.cs b/ErsatzTV.Core/Domain/MediaSource/EmbyMediaSource.cs
index 34404b057..06dc6e926 100644
--- a/ErsatzTV.Core/Domain/MediaSource/EmbyMediaSource.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/EmbyMediaSource.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class EmbyMediaSource : MediaSource
 {
-    public class EmbyMediaSource : MediaSource
-    {
-        public string ServerName { get; set; }
-        public string OperatingSystem { get; set; }
-        public List<EmbyConnection> Connections { get; set; }
-        public List<EmbyPathReplacement> PathReplacements { get; set; }
-    }
-}
+    public string ServerName { get; set; }
+    public string OperatingSystem { get; set; }
+    public List<EmbyConnection> Connections { get; set; }
+    public List<EmbyPathReplacement> PathReplacements { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/EmbyPathReplacement.cs b/ErsatzTV.Core/Domain/MediaSource/EmbyPathReplacement.cs
index 00ea50e4f..ec456a698 100644
--- a/ErsatzTV.Core/Domain/MediaSource/EmbyPathReplacement.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/EmbyPathReplacement.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class EmbyPathReplacement
 {
-    public class EmbyPathReplacement
-    {
-        public int Id { get; set; }
-        public string EmbyPath { get; set; }
-        public string LocalPath { get; set; }
-        public int EmbyMediaSourceId { get; set; }
-        public EmbyMediaSource EmbyMediaSource { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string EmbyPath { get; set; }
+    public string LocalPath { get; set; }
+    public int EmbyMediaSourceId { get; set; }
+    public EmbyMediaSource EmbyMediaSource { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/JellyfinConnection.cs b/ErsatzTV.Core/Domain/MediaSource/JellyfinConnection.cs
index f253880c8..21f3d42e1 100644
--- a/ErsatzTV.Core/Domain/MediaSource/JellyfinConnection.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/JellyfinConnection.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class JellyfinConnection
 {
-    public class JellyfinConnection
-    {
-        public int Id { get; set; }
-        public string Address { get; set; }
-        public int JellyfinMediaSourceId { get; set; }
-        public JellyfinMediaSource JellyfinMediaSource { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Address { get; set; }
+    public int JellyfinMediaSourceId { get; set; }
+    public JellyfinMediaSource JellyfinMediaSource { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/JellyfinMediaSource.cs b/ErsatzTV.Core/Domain/MediaSource/JellyfinMediaSource.cs
index 31116f42e..940498985 100644
--- a/ErsatzTV.Core/Domain/MediaSource/JellyfinMediaSource.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/JellyfinMediaSource.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class JellyfinMediaSource : MediaSource
 {
-    public class JellyfinMediaSource : MediaSource
-    {
-        public string ServerName { get; set; }
-        public string OperatingSystem { get; set; }
-        public List<JellyfinConnection> Connections { get; set; }
-        public List<JellyfinPathReplacement> PathReplacements { get; set; }
-    }
-}
+    public string ServerName { get; set; }
+    public string OperatingSystem { get; set; }
+    public List<JellyfinConnection> Connections { get; set; }
+    public List<JellyfinPathReplacement> PathReplacements { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/JellyfinPathReplacement.cs b/ErsatzTV.Core/Domain/MediaSource/JellyfinPathReplacement.cs
index 8717cfc53..c227a4794 100644
--- a/ErsatzTV.Core/Domain/MediaSource/JellyfinPathReplacement.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/JellyfinPathReplacement.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class JellyfinPathReplacement
 {
-    public class JellyfinPathReplacement
-    {
-        public int Id { get; set; }
-        public string JellyfinPath { get; set; }
-        public string LocalPath { get; set; }
-        public int JellyfinMediaSourceId { get; set; }
-        public JellyfinMediaSource JellyfinMediaSource { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string JellyfinPath { get; set; }
+    public string LocalPath { get; set; }
+    public int JellyfinMediaSourceId { get; set; }
+    public JellyfinMediaSource JellyfinMediaSource { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/LocalMediaSource.cs b/ErsatzTV.Core/Domain/MediaSource/LocalMediaSource.cs
index ad0c4642c..9b619a6af 100644
--- a/ErsatzTV.Core/Domain/MediaSource/LocalMediaSource.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/LocalMediaSource.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class LocalMediaSource : MediaSource
 {
-    public class LocalMediaSource : MediaSource
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/MediaSource.cs b/ErsatzTV.Core/Domain/MediaSource/MediaSource.cs
index 62340ebd6..207e7342d 100644
--- a/ErsatzTV.Core/Domain/MediaSource/MediaSource.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/MediaSource.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public abstract class MediaSource
 {
-    public abstract class MediaSource
-    {
-        public int Id { get; set; }
+    public int Id { get; set; }
 
-        public List<Library> Libraries { get; set; }
-    }
-}
+    public List<Library> Libraries { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/PlexConnection.cs b/ErsatzTV.Core/Domain/MediaSource/PlexConnection.cs
index 18313b8f2..286026b81 100644
--- a/ErsatzTV.Core/Domain/MediaSource/PlexConnection.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/PlexConnection.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlexConnection
 {
-    public class PlexConnection
-    {
-        public int Id { get; set; }
-        public bool IsActive { get; set; }
-        public string Uri { get; set; }
-        public int PlexMediaSourceId { get; set; }
-        public PlexMediaSource PlexMediaSource { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public bool IsActive { get; set; }
+    public string Uri { get; set; }
+    public int PlexMediaSourceId { get; set; }
+    public PlexMediaSource PlexMediaSource { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/PlexMediaSource.cs b/ErsatzTV.Core/Domain/MediaSource/PlexMediaSource.cs
index 38c6acf4e..924fc0c52 100644
--- a/ErsatzTV.Core/Domain/MediaSource/PlexMediaSource.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/PlexMediaSource.cs
@@ -1,17 +1,14 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class PlexMediaSource : MediaSource
 {
-    public class PlexMediaSource : MediaSource
-    {
-        public string ServerName { get; set; }
-        public string ProductVersion { get; set; }
-        public string Platform { get; set; }
-        public string PlatformVersion { get; set; }
-        public string ClientIdentifier { get; set; }
+    public string ServerName { get; set; }
+    public string ProductVersion { get; set; }
+    public string Platform { get; set; }
+    public string PlatformVersion { get; set; }
+    public string ClientIdentifier { get; set; }
 
-        // public bool IsOwned { get; set; }
-        public List<PlexConnection> Connections { get; set; }
-        public List<PlexPathReplacement> PathReplacements { get; set; }
-    }
-}
+    // public bool IsOwned { get; set; }
+    public List<PlexConnection> Connections { get; set; }
+    public List<PlexPathReplacement> PathReplacements { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MediaSource/PlexPathReplacement.cs b/ErsatzTV.Core/Domain/MediaSource/PlexPathReplacement.cs
index f5e5c71ff..8b317ef3b 100644
--- a/ErsatzTV.Core/Domain/MediaSource/PlexPathReplacement.cs
+++ b/ErsatzTV.Core/Domain/MediaSource/PlexPathReplacement.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlexPathReplacement
 {
-    public class PlexPathReplacement
-    {
-        public int Id { get; set; }
-        public string PlexPath { get; set; }
-        public string LocalPath { get; set; }
-        public int PlexMediaSourceId { get; set; }
-        public PlexMediaSource PlexMediaSource { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string PlexPath { get; set; }
+    public string LocalPath { get; set; }
+    public int PlexMediaSourceId { get; set; }
+    public PlexMediaSource PlexMediaSource { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Actor.cs b/ErsatzTV.Core/Domain/Metadata/Actor.cs
index 6aa671dd1..456db3d0f 100644
--- a/ErsatzTV.Core/Domain/Metadata/Actor.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Actor.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Actor
 {
-    public class Actor
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public string Role { get; set; }
-        public int? Order { get; set; }
-        public int? ArtworkId { get; set; }
-        public Artwork Artwork { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public string Role { get; set; }
+    public int? Order { get; set; }
+    public int? ArtworkId { get; set; }
+    public Artwork Artwork { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/ArtistMetadata.cs b/ErsatzTV.Core/Domain/Metadata/ArtistMetadata.cs
index 73ef9c69a..59d7dc7c0 100644
--- a/ErsatzTV.Core/Domain/Metadata/ArtistMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/ArtistMetadata.cs
@@ -1,15 +1,12 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class ArtistMetadata : Metadata
 {
-    public class ArtistMetadata : Metadata
-    {
-        public string Disambiguation { get; set; }
-        public string Biography { get; set; }
-        public string Formed { get; set; }
-        public int ArtistId { get; set; }
-        public Artist Artist { get; set; }
-        public List<Style> Styles { get; set; }
-        public List<Mood> Moods { get; set; }
-    }
-}
+    public string Disambiguation { get; set; }
+    public string Biography { get; set; }
+    public string Formed { get; set; }
+    public int ArtistId { get; set; }
+    public Artist Artist { get; set; }
+    public List<Style> Styles { get; set; }
+    public List<Mood> Moods { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Artwork.cs b/ErsatzTV.Core/Domain/Metadata/Artwork.cs
index d08cadeaf..05ace4473 100644
--- a/ErsatzTV.Core/Domain/Metadata/Artwork.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Artwork.cs
@@ -1,17 +1,14 @@
-using System;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Artwork
 {
-    public class Artwork
-    {
-        public int Id { get; set; }
-        public string Path { get; set; }
-        public string SourcePath { get; set; }
-        public string BlurHash43 { get; set; }
-        public string BlurHash54 { get; set; }
-        public string BlurHash64 { get; set; }
-        public ArtworkKind ArtworkKind { get; set; }
-        public DateTime DateAdded { get; set; }
-        public DateTime DateUpdated { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Path { get; set; }
+    public string SourcePath { get; set; }
+    public string BlurHash43 { get; set; }
+    public string BlurHash54 { get; set; }
+    public string BlurHash64 { get; set; }
+    public ArtworkKind ArtworkKind { get; set; }
+    public DateTime DateAdded { get; set; }
+    public DateTime DateUpdated { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/ArtworkKind.cs b/ErsatzTV.Core/Domain/Metadata/ArtworkKind.cs
index 47d89c1b6..7e217cdba 100644
--- a/ErsatzTV.Core/Domain/Metadata/ArtworkKind.cs
+++ b/ErsatzTV.Core/Domain/Metadata/ArtworkKind.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum ArtworkKind
 {
-    public enum ArtworkKind
-    {
-        Poster = 0,
-        Thumbnail = 1,
-        Logo = 2,
-        FanArt = 3,
-        Watermark = 4
-    }
-}
+    Poster = 0,
+    Thumbnail = 1,
+    Logo = 2,
+    FanArt = 3,
+    Watermark = 4
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Director.cs b/ErsatzTV.Core/Domain/Metadata/Director.cs
index 80c878892..a15c16f2d 100644
--- a/ErsatzTV.Core/Domain/Metadata/Director.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Director.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Director
 {
-    public class Director
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/EpisodeMetadata.cs b/ErsatzTV.Core/Domain/Metadata/EpisodeMetadata.cs
index 5652ebde2..5a7eb0a10 100644
--- a/ErsatzTV.Core/Domain/Metadata/EpisodeMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/EpisodeMetadata.cs
@@ -1,16 +1,13 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class EpisodeMetadata : Metadata
 {
-    public class EpisodeMetadata : Metadata
-    {
-        public int EpisodeNumber { get; set; }
-        public string Outline { get; set; }
-        public string Plot { get; set; }
-        public string Tagline { get; set; }
-        public int EpisodeId { get; set; }
-        public Episode Episode { get; set; }
-        public List<Director> Directors { get; set; }
-        public List<Writer> Writers { get; set; }
-    }
-}
+    public int EpisodeNumber { get; set; }
+    public string Outline { get; set; }
+    public string Plot { get; set; }
+    public string Tagline { get; set; }
+    public int EpisodeId { get; set; }
+    public Episode Episode { get; set; }
+    public List<Director> Directors { get; set; }
+    public List<Writer> Writers { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Genre.cs b/ErsatzTV.Core/Domain/Metadata/Genre.cs
index 16acb4bd3..c13bd24a5 100644
--- a/ErsatzTV.Core/Domain/Metadata/Genre.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Genre.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Genre
 {
-    public class Genre
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Metadata.cs b/ErsatzTV.Core/Domain/Metadata/Metadata.cs
index 9cda68ed1..f7c89bf77 100644
--- a/ErsatzTV.Core/Domain/Metadata/Metadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Metadata.cs
@@ -1,24 +1,20 @@
-using System;
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Metadata
 {
-    public class Metadata
-    {
-        public int Id { get; set; }
-        public MetadataKind MetadataKind { get; set; }
-        public string Title { get; set; }
-        public string OriginalTitle { get; set; }
-        public string SortTitle { get; set; }
-        public int? Year { get; set; }
-        public DateTime? ReleaseDate { get; set; }
-        public DateTime DateAdded { get; set; }
-        public DateTime DateUpdated { get; set; }
-        public List<Artwork> Artwork { get; set; }
-        public List<Genre> Genres { get; set; }
-        public List<Tag> Tags { get; set; }
-        public List<Studio> Studios { get; set; }
-        public List<Actor> Actors { get; set; }
-        public List<MetadataGuid> Guids { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public MetadataKind MetadataKind { get; set; }
+    public string Title { get; set; }
+    public string OriginalTitle { get; set; }
+    public string SortTitle { get; set; }
+    public int? Year { get; set; }
+    public DateTime? ReleaseDate { get; set; }
+    public DateTime DateAdded { get; set; }
+    public DateTime DateUpdated { get; set; }
+    public List<Artwork> Artwork { get; set; }
+    public List<Genre> Genres { get; set; }
+    public List<Tag> Tags { get; set; }
+    public List<Studio> Studios { get; set; }
+    public List<Actor> Actors { get; set; }
+    public List<MetadataGuid> Guids { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/MetadataGuid.cs b/ErsatzTV.Core/Domain/Metadata/MetadataGuid.cs
index c03389a08..00909142b 100644
--- a/ErsatzTV.Core/Domain/Metadata/MetadataGuid.cs
+++ b/ErsatzTV.Core/Domain/Metadata/MetadataGuid.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class MetadataGuid
 {
-    public class MetadataGuid
-    {
-        public int Id { get; set; }
-        public string Guid { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Guid { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/MetadataKind.cs b/ErsatzTV.Core/Domain/Metadata/MetadataKind.cs
index d0ec29f92..78db64ec5 100644
--- a/ErsatzTV.Core/Domain/Metadata/MetadataKind.cs
+++ b/ErsatzTV.Core/Domain/Metadata/MetadataKind.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum MetadataKind
 {
-    public enum MetadataKind
-    {
-        Fallback = 0,
-        Sidecar = 1,
-        External = 2,
-        Embedded = 3
-    }
-}
+    Fallback = 0,
+    Sidecar = 1,
+    External = 2,
+    Embedded = 3
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Mood.cs b/ErsatzTV.Core/Domain/Metadata/Mood.cs
index e29e067ea..e572886b0 100644
--- a/ErsatzTV.Core/Domain/Metadata/Mood.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Mood.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Mood
 {
-    public class Mood
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/MovieMetadata.cs b/ErsatzTV.Core/Domain/Metadata/MovieMetadata.cs
index f9709118f..4a34d88a2 100644
--- a/ErsatzTV.Core/Domain/Metadata/MovieMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/MovieMetadata.cs
@@ -1,16 +1,13 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class MovieMetadata : Metadata
 {
-    public class MovieMetadata : Metadata
-    {
-        public string ContentRating { get; set; }
-        public string Outline { get; set; }
-        public string Plot { get; set; }
-        public string Tagline { get; set; }
-        public int MovieId { get; set; }
-        public Movie Movie { get; set; }
-        public List<Director> Directors { get; set; }
-        public List<Writer> Writers { get; set; }
-    }
-}
+    public string ContentRating { get; set; }
+    public string Outline { get; set; }
+    public string Plot { get; set; }
+    public string Tagline { get; set; }
+    public int MovieId { get; set; }
+    public Movie Movie { get; set; }
+    public List<Director> Directors { get; set; }
+    public List<Writer> Writers { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/MusicVideoMetadata.cs b/ErsatzTV.Core/Domain/Metadata/MusicVideoMetadata.cs
index 8e08e8feb..3f2663490 100644
--- a/ErsatzTV.Core/Domain/Metadata/MusicVideoMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/MusicVideoMetadata.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class MusicVideoMetadata : Metadata
 {
-    public class MusicVideoMetadata : Metadata
-    {
-        public string Album { get; set; }
-        public string Plot { get; set; }
-        public int MusicVideoId { get; set; }
-        public MusicVideo MusicVideo { get; set; }
-    }
-}
+    public string Album { get; set; }
+    public string Plot { get; set; }
+    public int MusicVideoId { get; set; }
+    public MusicVideo MusicVideo { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/OtherVideoMetadata.cs b/ErsatzTV.Core/Domain/Metadata/OtherVideoMetadata.cs
index 925dccdba..bf3a24f19 100644
--- a/ErsatzTV.Core/Domain/Metadata/OtherVideoMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/OtherVideoMetadata.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class OtherVideoMetadata : Metadata
 {
-    public class OtherVideoMetadata : Metadata
-    {
-        public int OtherVideoId { get; set; }
-        public OtherVideo OtherVideo { get; set; }
-    }
-}
+    public int OtherVideoId { get; set; }
+    public OtherVideo OtherVideo { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/SeasonMetadata.cs b/ErsatzTV.Core/Domain/Metadata/SeasonMetadata.cs
index 19e3619a0..df79f85a0 100644
--- a/ErsatzTV.Core/Domain/Metadata/SeasonMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/SeasonMetadata.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class SeasonMetadata : Metadata
 {
-    public class SeasonMetadata : Metadata
-    {
-        public string Outline { get; set; }
-        public int SeasonId { get; set; }
-        public Season Season { get; set; }
-    }
-}
+    public string Outline { get; set; }
+    public int SeasonId { get; set; }
+    public Season Season { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/ShowMetadata.cs b/ErsatzTV.Core/Domain/Metadata/ShowMetadata.cs
index 54f5b3f46..9946733bc 100644
--- a/ErsatzTV.Core/Domain/Metadata/ShowMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/ShowMetadata.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class ShowMetadata : Metadata
 {
-    public class ShowMetadata : Metadata
-    {
-        public string ContentRating { get; set; }
-        public string Outline { get; set; }
-        public string Plot { get; set; }
-        public string Tagline { get; set; }
-        public int ShowId { get; set; }
-        public Show Show { get; set; }
-    }
-}
+    public string ContentRating { get; set; }
+    public string Outline { get; set; }
+    public string Plot { get; set; }
+    public string Tagline { get; set; }
+    public int ShowId { get; set; }
+    public Show Show { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/SongMetadata.cs b/ErsatzTV.Core/Domain/Metadata/SongMetadata.cs
index 1f74731d9..6db4c94d3 100644
--- a/ErsatzTV.Core/Domain/Metadata/SongMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/SongMetadata.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class SongMetadata : Metadata
 {
-    public class SongMetadata : Metadata
-    {
-        public string Album { get; set; }
-        public string Artist { get; set; }
-        public string Date { get; set; }
-        public string Track { get; set; }
-        public int SongId { get; set; }
-        public Song Song { get; set; }
-    }
-}
+    public string Album { get; set; }
+    public string Artist { get; set; }
+    public string Date { get; set; }
+    public string Track { get; set; }
+    public int SongId { get; set; }
+    public Song Song { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Studio.cs b/ErsatzTV.Core/Domain/Metadata/Studio.cs
index 06599470e..994cadefa 100644
--- a/ErsatzTV.Core/Domain/Metadata/Studio.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Studio.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Studio
 {
-    public class Studio
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Style.cs b/ErsatzTV.Core/Domain/Metadata/Style.cs
index d1c594de4..19112f148 100644
--- a/ErsatzTV.Core/Domain/Metadata/Style.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Style.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Style
 {
-    public class Style
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Tag.cs b/ErsatzTV.Core/Domain/Metadata/Tag.cs
index 844c7c898..d6457dc83 100644
--- a/ErsatzTV.Core/Domain/Metadata/Tag.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Tag.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Tag
 {
-    public class Tag
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Metadata/Writer.cs b/ErsatzTV.Core/Domain/Metadata/Writer.cs
index 48036b7fc..25cb0262e 100644
--- a/ErsatzTV.Core/Domain/Metadata/Writer.cs
+++ b/ErsatzTV.Core/Domain/Metadata/Writer.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class Writer
 {
-    public class Writer
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/MetadataSource.cs b/ErsatzTV.Core/Domain/MetadataSource.cs
index 3cb073041..f8cd5596f 100644
--- a/ErsatzTV.Core/Domain/MetadataSource.cs
+++ b/ErsatzTV.Core/Domain/MetadataSource.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum MetadataSource
 {
-    public enum MetadataSource
-    {
-        Fallback = 0,
-        Sidecar = 1
-    }
-}
+    Fallback = 0,
+    Sidecar = 1
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/PlaybackOrder.cs b/ErsatzTV.Core/Domain/PlaybackOrder.cs
index c5fd52621..d0b29f584 100644
--- a/ErsatzTV.Core/Domain/PlaybackOrder.cs
+++ b/ErsatzTV.Core/Domain/PlaybackOrder.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum PlaybackOrder
 {
-    public enum PlaybackOrder
-    {
-        Chronological = 1,
-        Random = 2,
-        Shuffle = 3,
-        ShuffleInOrder = 4
-    }
-}
+    Chronological = 1,
+    Random = 2,
+    Shuffle = 3,
+    ShuffleInOrder = 4
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Playout.cs b/ErsatzTV.Core/Domain/Playout.cs
index 619b6ab8c..4f3a5e887 100644
--- a/ErsatzTV.Core/Domain/Playout.cs
+++ b/ErsatzTV.Core/Domain/Playout.cs
@@ -1,19 +1,15 @@
-using System;
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class Playout
 {
-    public class Playout
-    {
-        public int Id { get; set; }
-        public int ChannelId { get; set; }
-        public Channel Channel { get; set; }
-        public int ProgramScheduleId { get; set; }
-        public ProgramSchedule ProgramSchedule { get; set; }
-        public ProgramSchedulePlayoutType ProgramSchedulePlayoutType { get; set; }
-        public List<PlayoutItem> Items { get; set; }
-        public PlayoutAnchor Anchor { get; set; }
-        public List<PlayoutProgramScheduleAnchor> ProgramScheduleAnchors { get; set; }
-        public TimeSpan? DailyRebuildTime { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public int ChannelId { get; set; }
+    public Channel Channel { get; set; }
+    public int ProgramScheduleId { get; set; }
+    public ProgramSchedule ProgramSchedule { get; set; }
+    public ProgramSchedulePlayoutType ProgramSchedulePlayoutType { get; set; }
+    public List<PlayoutItem> Items { get; set; }
+    public PlayoutAnchor Anchor { get; set; }
+    public List<PlayoutProgramScheduleAnchor> ProgramScheduleAnchors { get; set; }
+    public TimeSpan? DailyRebuildTime { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/PlayoutAnchor.cs b/ErsatzTV.Core/Domain/PlayoutAnchor.cs
index dec40e4ac..23ea8c1b9 100644
--- a/ErsatzTV.Core/Domain/PlayoutAnchor.cs
+++ b/ErsatzTV.Core/Domain/PlayoutAnchor.cs
@@ -1,23 +1,18 @@
-using System;
-using LanguageExt;
-using static LanguageExt.Prelude;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class PlayoutAnchor
 {
-    public class PlayoutAnchor
-    {
-        public CollectionEnumeratorState ScheduleItemsEnumeratorState { get; set; }
-        public DateTime NextStart { get; set; }
-        public int? MultipleRemaining { get; set; }
-        public DateTime? DurationFinish { get; set; }
-        public bool InFlood { get; set; }
-        public bool InDurationFiller { get; set; }
-        public int NextGuideGroup { get; set; }
+    public CollectionEnumeratorState ScheduleItemsEnumeratorState { get; set; }
+    public DateTime NextStart { get; set; }
+    public int? MultipleRemaining { get; set; }
+    public DateTime? DurationFinish { get; set; }
+    public bool InFlood { get; set; }
+    public bool InDurationFiller { get; set; }
+    public int NextGuideGroup { get; set; }
 
-        public DateTimeOffset NextStartOffset => new DateTimeOffset(NextStart, TimeSpan.Zero).ToLocalTime();
+    public DateTimeOffset NextStartOffset => new DateTimeOffset(NextStart, TimeSpan.Zero).ToLocalTime();
 
-        public Option<DateTimeOffset> DurationFinishOffset =>
-            Optional(DurationFinish)
-                .Map(durationFinish => new DateTimeOffset(durationFinish, TimeSpan.Zero).ToLocalTime());
-    }
-}
+    public Option<DateTimeOffset> DurationFinishOffset =>
+        Optional(DurationFinish)
+            .Map(durationFinish => new DateTimeOffset(durationFinish, TimeSpan.Zero).ToLocalTime());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/PlayoutItem.cs b/ErsatzTV.Core/Domain/PlayoutItem.cs
index db1bca776..efa2f94c3 100644
--- a/ErsatzTV.Core/Domain/PlayoutItem.cs
+++ b/ErsatzTV.Core/Domain/PlayoutItem.cs
@@ -1,49 +1,47 @@
-using System;
-using System.Diagnostics;
+using System.Diagnostics;
 using ErsatzTV.Core.Domain.Filler;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+[DebuggerDisplay("{MediaItemId} - {Start} - {Finish}")]
+public class PlayoutItem
 {
-    [DebuggerDisplay("{MediaItemId} - {Start} - {Finish}")]
-    public class PlayoutItem
-    {
-        public int Id { get; set; }
-        public int MediaItemId { get; set; }
-        public MediaItem MediaItem { get; set; }
-        public DateTime Start { get; set; }
-        public DateTime Finish { get; set; }
-        public DateTime? GuideFinish { get; set; }
-        public string CustomTitle { get; set; }
-        public int GuideGroup { get; set; }
-        public FillerKind FillerKind { get; set; }
-        public int PlayoutId { get; set; }
-        public Playout Playout { get; set; }
-        public TimeSpan InPoint { get; set; }
-        public TimeSpan OutPoint { get; set; }
-        public string ChapterTitle { get; set; }
+    public int Id { get; set; }
+    public int MediaItemId { get; set; }
+    public MediaItem MediaItem { get; set; }
+    public DateTime Start { get; set; }
+    public DateTime Finish { get; set; }
+    public DateTime? GuideFinish { get; set; }
+    public string CustomTitle { get; set; }
+    public int GuideGroup { get; set; }
+    public FillerKind FillerKind { get; set; }
+    public int PlayoutId { get; set; }
+    public Playout Playout { get; set; }
+    public TimeSpan InPoint { get; set; }
+    public TimeSpan OutPoint { get; set; }
+    public string ChapterTitle { get; set; }
 
-        public DateTimeOffset StartOffset => new DateTimeOffset(Start, TimeSpan.Zero).ToLocalTime();
-        public DateTimeOffset FinishOffset => new DateTimeOffset(Finish, TimeSpan.Zero).ToLocalTime();
-        public DateTimeOffset? GuideFinishOffset => GuideFinish.HasValue
-            ? new DateTimeOffset(GuideFinish.Value, TimeSpan.Zero).ToLocalTime()
-            : null;
+    public DateTimeOffset StartOffset => new DateTimeOffset(Start, TimeSpan.Zero).ToLocalTime();
+    public DateTimeOffset FinishOffset => new DateTimeOffset(Finish, TimeSpan.Zero).ToLocalTime();
+    public DateTimeOffset? GuideFinishOffset => GuideFinish.HasValue
+        ? new DateTimeOffset(GuideFinish.Value, TimeSpan.Zero).ToLocalTime()
+        : null;
 
-        public PlayoutItem ForChapter(MediaChapter chapter) =>
-            new()
-            {
-                MediaItemId = MediaItemId,
-                MediaItem = MediaItem,
-                Start = Start,
-                Finish = Start + chapter.EndTime - chapter.StartTime,
-                GuideFinish = GuideFinish,
-                CustomTitle = CustomTitle,
-                GuideGroup = GuideGroup,
-                FillerKind = FillerKind,
-                PlayoutId = PlayoutId,
-                Playout = Playout,
-                InPoint = chapter.StartTime,
-                OutPoint = chapter.EndTime,
-                ChapterTitle = chapter.Title
-            };
-    }
-}
+    public PlayoutItem ForChapter(MediaChapter chapter) =>
+        new()
+        {
+            MediaItemId = MediaItemId,
+            MediaItem = MediaItem,
+            Start = Start,
+            Finish = Start + chapter.EndTime - chapter.StartTime,
+            GuideFinish = GuideFinish,
+            CustomTitle = CustomTitle,
+            GuideGroup = GuideGroup,
+            FillerKind = FillerKind,
+            PlayoutId = PlayoutId,
+            Playout = Playout,
+            InPoint = chapter.StartTime,
+            OutPoint = chapter.EndTime,
+            ChapterTitle = chapter.Title
+        };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/PlayoutMode.cs b/ErsatzTV.Core/Domain/PlayoutMode.cs
index b2440063e..86ebc7962 100644
--- a/ErsatzTV.Core/Domain/PlayoutMode.cs
+++ b/ErsatzTV.Core/Domain/PlayoutMode.cs
@@ -1,25 +1,24 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum PlayoutMode
 {
-    public enum PlayoutMode
-    {
-        /// <summary>
-        ///     Play items one after the other until a fixed start item is encountered
-        /// </summary>
-        Flood = 1,
+    /// <summary>
+    ///     Play items one after the other until a fixed start item is encountered
+    /// </summary>
+    Flood = 1,
 
-        /// <summary>
-        ///     Play one item from the collection
-        /// </summary>
-        One = 2,
+    /// <summary>
+    ///     Play one item from the collection
+    /// </summary>
+    One = 2,
 
-        /// <summary>
-        ///     Play a variable number of items from the collection
-        /// </summary>
-        Multiple = 3,
+    /// <summary>
+    ///     Play a variable number of items from the collection
+    /// </summary>
+    Multiple = 3,
 
-        /// <summary>
-        ///     Play however many items will fit in the specified duration
-        /// </summary>
-        Duration = 4
-    }
-}
+    /// <summary>
+    ///     Play however many items will fit in the specified duration
+    /// </summary>
+    Duration = 4
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/PlayoutProgramScheduleAnchor.cs b/ErsatzTV.Core/Domain/PlayoutProgramScheduleAnchor.cs
index 2e94c47a0..7ce991d88 100644
--- a/ErsatzTV.Core/Domain/PlayoutProgramScheduleAnchor.cs
+++ b/ErsatzTV.Core/Domain/PlayoutProgramScheduleAnchor.cs
@@ -1,21 +1,20 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class PlayoutProgramScheduleAnchor
 {
-    public class PlayoutProgramScheduleAnchor
-    {
-        public int Id { get; set; }
-        public int PlayoutId { get; set; }
-        public Playout Playout { get; set; }
-        public int ProgramScheduleId { get; set; }
-        public ProgramSchedule ProgramSchedule { get; set; }
-        public ProgramScheduleItemCollectionType CollectionType { get; set; }
-        public int? CollectionId { get; set; }
-        public Collection Collection { get; set; }
-        public int? MultiCollectionId { get; set; }
-        public MultiCollection MultiCollection { get; set; }
-        public int? SmartCollectionId { get; set; }
-        public SmartCollection SmartCollection { get; set; }
-        public int? MediaItemId { get; set; }
-        public MediaItem MediaItem { get; set; }
-        public CollectionEnumeratorState EnumeratorState { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public int PlayoutId { get; set; }
+    public Playout Playout { get; set; }
+    public int ProgramScheduleId { get; set; }
+    public ProgramSchedule ProgramSchedule { get; set; }
+    public ProgramScheduleItemCollectionType CollectionType { get; set; }
+    public int? CollectionId { get; set; }
+    public Collection Collection { get; set; }
+    public int? MultiCollectionId { get; set; }
+    public MultiCollection MultiCollection { get; set; }
+    public int? SmartCollectionId { get; set; }
+    public SmartCollection SmartCollection { get; set; }
+    public int? MediaItemId { get; set; }
+    public MediaItem MediaItem { get; set; }
+    public CollectionEnumeratorState EnumeratorState { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ProgramSchedule.cs b/ErsatzTV.Core/Domain/ProgramSchedule.cs
index 4e34694d6..fd504475b 100644
--- a/ErsatzTV.Core/Domain/ProgramSchedule.cs
+++ b/ErsatzTV.Core/Domain/ProgramSchedule.cs
@@ -1,15 +1,12 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class ProgramSchedule
 {
-    public class ProgramSchedule
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public bool KeepMultiPartEpisodesTogether { get; set; }
-        public bool TreatCollectionsAsShows { get; set; }
-        public bool ShuffleScheduleItems { get; set; }
-        public List<ProgramScheduleItem> Items { get; set; }
-        public List<Playout> Playouts { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public bool KeepMultiPartEpisodesTogether { get; set; }
+    public bool TreatCollectionsAsShows { get; set; }
+    public bool ShuffleScheduleItems { get; set; }
+    public List<ProgramScheduleItem> Items { get; set; }
+    public List<Playout> Playouts { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ProgramScheduleItem.cs b/ErsatzTV.Core/Domain/ProgramScheduleItem.cs
index d752403db..74ed668c6 100644
--- a/ErsatzTV.Core/Domain/ProgramScheduleItem.cs
+++ b/ErsatzTV.Core/Domain/ProgramScheduleItem.cs
@@ -1,37 +1,35 @@
-using System;
-using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Domain.Filler;
 
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public abstract class ProgramScheduleItem
 {
-    public abstract class ProgramScheduleItem
-    {
-        public int Id { get; set; }
-        public int Index { get; set; }
-        public StartType StartType => StartTime.HasValue ? StartType.Fixed : StartType.Dynamic;
-        public TimeSpan? StartTime { get; set; }
-        public ProgramScheduleItemCollectionType CollectionType { get; set; }
-        public GuideMode GuideMode { get; set; }
-        public string CustomTitle { get; set; }
-        public int ProgramScheduleId { get; set; }
-        public ProgramSchedule ProgramSchedule { get; set; }
-        public int? CollectionId { get; set; }
-        public Collection Collection { get; set; }
-        public int? MediaItemId { get; set; }
-        public MediaItem MediaItem { get; set; }
-        public int? MultiCollectionId { get; set; }
-        public MultiCollection MultiCollection { get; set; }
-        public int? SmartCollectionId { get; set; }
-        public SmartCollection SmartCollection { get; set; }
-        public PlaybackOrder PlaybackOrder { get; set; }
-        public int? PreRollFillerId { get; set; }
-        public FillerPreset PreRollFiller { get; set; }
-        public int? MidRollFillerId { get; set; }
-        public FillerPreset MidRollFiller { get; set; }
-        public int? PostRollFillerId { get; set; }
-        public FillerPreset PostRollFiller { get; set; }
-        public int? TailFillerId { get; set; }
-        public FillerPreset TailFiller { get; set; }
-        public int? FallbackFillerId { get; set; }
-        public FillerPreset FallbackFiller { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public int Index { get; set; }
+    public StartType StartType => StartTime.HasValue ? StartType.Fixed : StartType.Dynamic;
+    public TimeSpan? StartTime { get; set; }
+    public ProgramScheduleItemCollectionType CollectionType { get; set; }
+    public GuideMode GuideMode { get; set; }
+    public string CustomTitle { get; set; }
+    public int ProgramScheduleId { get; set; }
+    public ProgramSchedule ProgramSchedule { get; set; }
+    public int? CollectionId { get; set; }
+    public Collection Collection { get; set; }
+    public int? MediaItemId { get; set; }
+    public MediaItem MediaItem { get; set; }
+    public int? MultiCollectionId { get; set; }
+    public MultiCollection MultiCollection { get; set; }
+    public int? SmartCollectionId { get; set; }
+    public SmartCollection SmartCollection { get; set; }
+    public PlaybackOrder PlaybackOrder { get; set; }
+    public int? PreRollFillerId { get; set; }
+    public FillerPreset PreRollFiller { get; set; }
+    public int? MidRollFillerId { get; set; }
+    public FillerPreset MidRollFiller { get; set; }
+    public int? PostRollFillerId { get; set; }
+    public FillerPreset PostRollFiller { get; set; }
+    public int? TailFillerId { get; set; }
+    public FillerPreset TailFiller { get; set; }
+    public int? FallbackFillerId { get; set; }
+    public FillerPreset FallbackFiller { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ProgramScheduleItemCollectionType.cs b/ErsatzTV.Core/Domain/ProgramScheduleItemCollectionType.cs
index 27499a5d6..19f3d4285 100644
--- a/ErsatzTV.Core/Domain/ProgramScheduleItemCollectionType.cs
+++ b/ErsatzTV.Core/Domain/ProgramScheduleItemCollectionType.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum ProgramScheduleItemCollectionType
 {
-    public enum ProgramScheduleItemCollectionType
-    {
-        Collection = 0,
-        TelevisionShow = 1,
-        TelevisionSeason = 2,
-        Artist = 3,
-        MultiCollection = 4,
-        SmartCollection = 5
-    }
-}
+    Collection = 0,
+    TelevisionShow = 1,
+    TelevisionSeason = 2,
+    Artist = 3,
+    MultiCollection = 4,
+    SmartCollection = 5
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ProgramScheduleItemDuration.cs b/ErsatzTV.Core/Domain/ProgramScheduleItemDuration.cs
index 561d89e9f..341622a29 100644
--- a/ErsatzTV.Core/Domain/ProgramScheduleItemDuration.cs
+++ b/ErsatzTV.Core/Domain/ProgramScheduleItemDuration.cs
@@ -1,10 +1,7 @@
-using System;
+namespace ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Domain
+public class ProgramScheduleItemDuration : ProgramScheduleItem
 {
-    public class ProgramScheduleItemDuration : ProgramScheduleItem
-    {
-        public TimeSpan PlayoutDuration { get; set; }
-        public TailMode TailMode { get; set; }
-    }
-}
+    public TimeSpan PlayoutDuration { get; set; }
+    public TailMode TailMode { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ProgramScheduleItemFlood.cs b/ErsatzTV.Core/Domain/ProgramScheduleItemFlood.cs
index dbad4312d..ba9baa3c5 100644
--- a/ErsatzTV.Core/Domain/ProgramScheduleItemFlood.cs
+++ b/ErsatzTV.Core/Domain/ProgramScheduleItemFlood.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class ProgramScheduleItemFlood : ProgramScheduleItem
 {
-    public class ProgramScheduleItemFlood : ProgramScheduleItem
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ProgramScheduleItemMultiple.cs b/ErsatzTV.Core/Domain/ProgramScheduleItemMultiple.cs
index 9f86437fd..df6230221 100644
--- a/ErsatzTV.Core/Domain/ProgramScheduleItemMultiple.cs
+++ b/ErsatzTV.Core/Domain/ProgramScheduleItemMultiple.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class ProgramScheduleItemMultiple : ProgramScheduleItem
 {
-    public class ProgramScheduleItemMultiple : ProgramScheduleItem
-    {
-        public int Count { get; set; }
-    }
-}
+    public int Count { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ProgramScheduleItemOne.cs b/ErsatzTV.Core/Domain/ProgramScheduleItemOne.cs
index 8fd15250a..a7cbc028d 100644
--- a/ErsatzTV.Core/Domain/ProgramScheduleItemOne.cs
+++ b/ErsatzTV.Core/Domain/ProgramScheduleItemOne.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public class ProgramScheduleItemOne : ProgramScheduleItem
 {
-    public class ProgramScheduleItemOne : ProgramScheduleItem
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/ProgramSchedulePlayoutType.cs b/ErsatzTV.Core/Domain/ProgramSchedulePlayoutType.cs
index a20695dfc..da736678b 100644
--- a/ErsatzTV.Core/Domain/ProgramSchedulePlayoutType.cs
+++ b/ErsatzTV.Core/Domain/ProgramSchedulePlayoutType.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum ProgramSchedulePlayoutType
 {
-    public enum ProgramSchedulePlayoutType
-    {
-        None = 0,
-        Flood,
-        Daily
-    }
-}
+    None = 0,
+    Flood,
+    Daily
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/Resolution.cs b/ErsatzTV.Core/Domain/Resolution.cs
index f34af22f1..1d27c2517 100644
--- a/ErsatzTV.Core/Domain/Resolution.cs
+++ b/ErsatzTV.Core/Domain/Resolution.cs
@@ -1,14 +1,13 @@
 using ErsatzTV.Core.Interfaces.FFmpeg;
 
-namespace ErsatzTV.Core.Domain
-{
-    public class Resolution : IDisplaySize
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public int Height { get; set; }
-        public int Width { get; set; }
+namespace ErsatzTV.Core.Domain;
 
-        public override string ToString() => $"{Width}x{Height}";
-    }
-}
+public class Resolution : IDisplaySize
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public int Height { get; set; }
+    public int Width { get; set; }
+
+    public override string ToString() => $"{Width}x{Height}";
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/StartType.cs b/ErsatzTV.Core/Domain/StartType.cs
index 735e87e72..c33d74d57 100644
--- a/ErsatzTV.Core/Domain/StartType.cs
+++ b/ErsatzTV.Core/Domain/StartType.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum StartType
 {
-    public enum StartType
-    {
-        Dynamic = 1,
-        Fixed = 2
-    }
-}
+    Dynamic = 1,
+    Fixed = 2
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/StreamingMode.cs b/ErsatzTV.Core/Domain/StreamingMode.cs
index 98f9b35f8..64f80bbeb 100644
--- a/ErsatzTV.Core/Domain/StreamingMode.cs
+++ b/ErsatzTV.Core/Domain/StreamingMode.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum StreamingMode
 {
-    public enum StreamingMode
-    {
-        TransportStream = 1,
-        HttpLiveStreamingDirect = 2,
+    TransportStream = 1,
+    HttpLiveStreamingDirect = 2,
 //        HttpLiveStreamingHybrid = 3,
-        HttpLiveStreamingSegmenter = 4,
-        TransportStreamHybrid = 5
-    }
-}
+    HttpLiveStreamingSegmenter = 4,
+    TransportStreamHybrid = 5
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Domain/TailMode.cs b/ErsatzTV.Core/Domain/TailMode.cs
index 8ffa46101..0175d9c93 100644
--- a/ErsatzTV.Core/Domain/TailMode.cs
+++ b/ErsatzTV.Core/Domain/TailMode.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Domain
+namespace ErsatzTV.Core.Domain;
+
+public enum TailMode
 {
-    public enum TailMode
-    {
-        None = 0,
-        Offline = 1,
-        Slate = 2,
-        Filler = 3
-    }
-}
+    None = 0,
+    Offline = 1,
+    Slate = 2,
+    Filler = 3
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Emby/EmbyItemEtag.cs b/ErsatzTV.Core/Emby/EmbyItemEtag.cs
index b4ecb7d9d..3d19df15e 100644
--- a/ErsatzTV.Core/Emby/EmbyItemEtag.cs
+++ b/ErsatzTV.Core/Emby/EmbyItemEtag.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Emby
+namespace ErsatzTV.Core.Emby;
+
+public class EmbyItemEtag
 {
-    public class EmbyItemEtag
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Emby/EmbyMovieLibraryScanner.cs b/ErsatzTV.Core/Emby/EmbyMovieLibraryScanner.cs
index df33008eb..5463ab0d0 100644
--- a/ErsatzTV.Core/Emby/EmbyMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Emby/EmbyMovieLibraryScanner.cs
@@ -1,234 +1,227 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Emby
+namespace ErsatzTV.Core.Emby;
+
+public class EmbyMovieLibraryScanner : IEmbyMovieLibraryScanner
 {
-    public class EmbyMovieLibraryScanner : IEmbyMovieLibraryScanner
+    private readonly IEmbyApiClient _embyApiClient;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalStatisticsProvider _localStatisticsProvider;
+    private readonly ILogger<EmbyMovieLibraryScanner> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediator _mediator;
+    private readonly IMovieRepository _movieRepository;
+    private readonly IEmbyPathReplacementService _pathReplacementService;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+
+    public EmbyMovieLibraryScanner(
+        IEmbyApiClient embyApiClient,
+        ISearchIndex searchIndex,
+        IMediator mediator,
+        IMovieRepository movieRepository,
+        ISearchRepository searchRepository,
+        IEmbyPathReplacementService pathReplacementService,
+        IMediaSourceRepository mediaSourceRepository,
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILogger<EmbyMovieLibraryScanner> logger)
     {
-        private readonly IEmbyApiClient _embyApiClient;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly ILogger<EmbyMovieLibraryScanner> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMediator _mediator;
-        private readonly IMovieRepository _movieRepository;
-        private readonly IEmbyPathReplacementService _pathReplacementService;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
+        _embyApiClient = embyApiClient;
+        _searchIndex = searchIndex;
+        _mediator = mediator;
+        _movieRepository = movieRepository;
+        _searchRepository = searchRepository;
+        _pathReplacementService = pathReplacementService;
+        _mediaSourceRepository = mediaSourceRepository;
+        _localFileSystem = localFileSystem;
+        _localStatisticsProvider = localStatisticsProvider;
+        _logger = logger;
+    }
 
-        public EmbyMovieLibraryScanner(
-            IEmbyApiClient embyApiClient,
-            ISearchIndex searchIndex,
-            IMediator mediator,
-            IMovieRepository movieRepository,
-            ISearchRepository searchRepository,
-            IEmbyPathReplacementService pathReplacementService,
-            IMediaSourceRepository mediaSourceRepository,
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILogger<EmbyMovieLibraryScanner> logger)
-        {
-            _embyApiClient = embyApiClient;
-            _searchIndex = searchIndex;
-            _mediator = mediator;
-            _movieRepository = movieRepository;
-            _searchRepository = searchRepository;
-            _pathReplacementService = pathReplacementService;
-            _mediaSourceRepository = mediaSourceRepository;
-            _localFileSystem = localFileSystem;
-            _localStatisticsProvider = localStatisticsProvider;
-            _logger = logger;
-        }
+    public async Task<Either<BaseError, Unit>> ScanLibrary(
+        string address,
+        string apiKey,
+        EmbyLibrary library,
+        string ffprobePath)
+    {
+        List<EmbyItemEtag> existingMovies = await _movieRepository.GetExistingEmbyMovies(library);
 
-        public async Task<Either<BaseError, Unit>> ScanLibrary(
-            string address,
-            string apiKey,
-            EmbyLibrary library,
-            string ffprobePath)
-        {
-            List<EmbyItemEtag> existingMovies = await _movieRepository.GetExistingEmbyMovies(library);
+        // TODO: maybe get quick list of item ids and etags from api to compare first
+        // TODO: paging?
 
-            // TODO: maybe get quick list of item ids and etags from api to compare first
-            // TODO: paging?
+        List<EmbyPathReplacement> pathReplacements = await _mediaSourceRepository
+            .GetEmbyPathReplacements(library.MediaSourceId);
 
-            List<EmbyPathReplacement> pathReplacements = await _mediaSourceRepository
-                .GetEmbyPathReplacements(library.MediaSourceId);
+        Either<BaseError, List<EmbyMovie>> maybeMovies = await _embyApiClient.GetMovieLibraryItems(
+            address,
+            apiKey,
+            library.MediaSourceId,
+            library.ItemId);
 
-            Either<BaseError, List<EmbyMovie>> maybeMovies = await _embyApiClient.GetMovieLibraryItems(
-                address,
-                apiKey,
-                library.MediaSourceId,
-                library.ItemId);
-
-            await maybeMovies.Match(
-                async movies =>
+        await maybeMovies.Match(
+            async movies =>
+            {
+                var validMovies = new List<EmbyMovie>();
+                foreach (EmbyMovie movie in movies.OrderBy(m => m.MovieMetadata.Head().Title))
                 {
-                    var validMovies = new List<EmbyMovie>();
-                    foreach (EmbyMovie movie in movies.OrderBy(m => m.MovieMetadata.Head().Title))
+                    string localPath = _pathReplacementService.GetReplacementEmbyPath(
+                        pathReplacements,
+                        movie.MediaVersions.Head().MediaFiles.Head().Path,
+                        false);
+
+                    if (!_localFileSystem.FileExists(localPath))
+                    {
+                        _logger.LogWarning("Skipping emby movie that does not exist at {Path}", localPath);
+                    }
+                    else
+                    {
+                        validMovies.Add(movie);
+                    }
+                }
+
+                foreach (EmbyMovie incoming in validMovies)
+                {
+                    EmbyMovie incomingMovie = incoming;
+                        
+                    decimal percentCompletion = (decimal) validMovies.IndexOf(incoming) / validMovies.Count;
+                    await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
+
+                    Option<EmbyItemEtag> maybeExisting =
+                        existingMovies.Find(ie => ie.ItemId == incoming.ItemId);
+
+                    var updateStatistics = false;
+
+                    await maybeExisting.Match(
+                        async existing =>
+                        {
+                            try
+                            {
+                                if (existing.Etag == incoming.Etag)
+                                {
+                                    // _logger.LogDebug(
+                                    //     $"NOOP: Etag has not changed for movie {incoming.MovieMetadata.Head().Title}");
+                                    return;
+                                }
+
+                                _logger.LogDebug(
+                                    "UPDATE: Etag has changed for movie {Movie}",
+                                    incoming.MovieMetadata.Head().Title);
+
+                                updateStatistics = true;
+                                incoming.LibraryPathId = library.Paths.Head().Id;
+                                Option<EmbyMovie> maybeUpdated = await _movieRepository.UpdateEmby(incoming);
+                                foreach (EmbyMovie updated in maybeUpdated)
+                                {
+                                    await _searchIndex.UpdateItems(
+                                        _searchRepository,
+                                        new List<MediaItem> { updated });
+
+                                    incomingMovie = updated;
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                updateStatistics = false;
+                                _logger.LogError(
+                                    ex,
+                                    "Error updating movie {Movie}",
+                                    incoming.MovieMetadata.Head().Title);
+                            }
+                        },
+                        async () =>
+                        {
+                            try
+                            {
+                                // _logger.LogDebug(
+                                //     $"INSERT: Item id is new for movie {incoming.MovieMetadata.Head().Title}");
+
+                                updateStatistics = true;
+                                incoming.LibraryPathId = library.Paths.Head().Id;
+                                if (await _movieRepository.AddEmby(incoming))
+                                {
+                                    await _searchIndex.AddItems(
+                                        _searchRepository,
+                                        new List<MediaItem> { incoming });
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                updateStatistics = false;
+                                _logger.LogError(
+                                    ex,
+                                    "Error adding movie {Movie}",
+                                    incoming.MovieMetadata.Head().Title);
+                            }
+                        });
+
+                    if (updateStatistics)
                     {
                         string localPath = _pathReplacementService.GetReplacementEmbyPath(
                             pathReplacements,
-                            movie.MediaVersions.Head().MediaFiles.Head().Path,
+                            incoming.MediaVersions.Head().MediaFiles.Head().Path,
                             false);
 
-                        if (!_localFileSystem.FileExists(localPath))
-                        {
-                            _logger.LogWarning("Skipping emby movie that does not exist at {Path}", localPath);
-                        }
-                        else
-                        {
-                            validMovies.Add(movie);
-                        }
-                    }
+                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
+                        Either<BaseError, bool> refreshResult =
+                            await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingMovie, localPath);
 
-                    foreach (EmbyMovie incoming in validMovies)
-                    {
-                        EmbyMovie incomingMovie = incoming;
-                        
-                        decimal percentCompletion = (decimal) validMovies.IndexOf(incoming) / validMovies.Count;
-                        await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
-
-                        Option<EmbyItemEtag> maybeExisting =
-                            existingMovies.Find(ie => ie.ItemId == incoming.ItemId);
-
-                        var updateStatistics = false;
-
-                        await maybeExisting.Match(
-                            async existing =>
+                        await refreshResult.Match(
+                            async _ =>
                             {
-                                try
+                                Option<MediaItem> updated = await _searchRepository.GetItemToIndex(incomingMovie.Id);
+                                if (updated.IsSome)
                                 {
-                                    if (existing.Etag == incoming.Etag)
-                                    {
-                                        // _logger.LogDebug(
-                                        //     $"NOOP: Etag has not changed for movie {incoming.MovieMetadata.Head().Title}");
-                                        return;
-                                    }
-
-                                    _logger.LogDebug(
-                                        "UPDATE: Etag has changed for movie {Movie}",
-                                        incoming.MovieMetadata.Head().Title);
-
-                                    updateStatistics = true;
-                                    incoming.LibraryPathId = library.Paths.Head().Id;
-                                    Option<EmbyMovie> maybeUpdated = await _movieRepository.UpdateEmby(incoming);
-                                    foreach (EmbyMovie updated in maybeUpdated)
-                                    {
-                                        await _searchIndex.UpdateItems(
-                                            _searchRepository,
-                                            new List<MediaItem> { updated });
-
-                                        incomingMovie = updated;
-                                    }
-                                }
-                                catch (Exception ex)
-                                {
-                                    updateStatistics = false;
-                                    _logger.LogError(
-                                        ex,
-                                        "Error updating movie {Movie}",
-                                        incoming.MovieMetadata.Head().Title);
+                                    await _searchIndex.UpdateItems(
+                                        _searchRepository,
+                                        new List<MediaItem> { updated.ValueUnsafe() });
                                 }
                             },
-                            async () =>
+                            error =>
                             {
-                                try
-                                {
-                                    // _logger.LogDebug(
-                                    //     $"INSERT: Item id is new for movie {incoming.MovieMetadata.Head().Title}");
+                                _logger.LogWarning(
+                                    "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                                    "Statistics",
+                                    localPath,
+                                    error.Value);
 
-                                    updateStatistics = true;
-                                    incoming.LibraryPathId = library.Paths.Head().Id;
-                                    if (await _movieRepository.AddEmby(incoming))
-                                    {
-                                        await _searchIndex.AddItems(
-                                            _searchRepository,
-                                            new List<MediaItem> { incoming });
-                                    }
-                                }
-                                catch (Exception ex)
-                                {
-                                    updateStatistics = false;
-                                    _logger.LogError(
-                                        ex,
-                                        "Error adding movie {Movie}",
-                                        incoming.MovieMetadata.Head().Title);
-                                }
+                                return Task.CompletedTask;
                             });
-
-                        if (updateStatistics)
-                        {
-                            string localPath = _pathReplacementService.GetReplacementEmbyPath(
-                                pathReplacements,
-                                incoming.MediaVersions.Head().MediaFiles.Head().Path,
-                                false);
-
-                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
-                            Either<BaseError, bool> refreshResult =
-                                await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingMovie, localPath);
-
-                            await refreshResult.Match(
-                                async _ =>
-                                {
-                                    Option<MediaItem> updated = await _searchRepository.GetItemToIndex(incomingMovie.Id);
-                                    if (updated.IsSome)
-                                    {
-                                        await _searchIndex.UpdateItems(
-                                            _searchRepository,
-                                            new List<MediaItem> { updated.ValueUnsafe() });
-                                    }
-                                },
-                                error =>
-                                {
-                                    _logger.LogWarning(
-                                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                                        "Statistics",
-                                        localPath,
-                                        error.Value);
-
-                                    return Task.CompletedTask;
-                                });
-                        }
-
-                        // TODO: figure out how to rebuild playlists
                     }
 
-                    var incomingMovieIds = validMovies.Map(s => s.ItemId).ToList();
-                    var movieIds = existingMovies
-                        .Filter(i => !incomingMovieIds.Contains(i.ItemId))
-                        .Map(m => m.ItemId)
-                        .ToList();
-                    List<int> ids = await _movieRepository.RemoveMissingEmbyMovies(library, movieIds);
-                    await _searchIndex.RemoveItems(ids);
+                    // TODO: figure out how to rebuild playlists
+                }
 
-                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
-                    _searchIndex.Commit();
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Error synchronizing emby library {Path}: {Error}",
-                        library.Name,
-                        error.Value);
+                var incomingMovieIds = validMovies.Map(s => s.ItemId).ToList();
+                var movieIds = existingMovies
+                    .Filter(i => !incomingMovieIds.Contains(i.ItemId))
+                    .Map(m => m.ItemId)
+                    .ToList();
+                List<int> ids = await _movieRepository.RemoveMissingEmbyMovies(library, movieIds);
+                await _searchIndex.RemoveItems(ids);
 
-                    return Task.CompletedTask;
-                });
+                await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+                _searchIndex.Commit();
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing emby library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
 
-            _searchIndex.Commit();
-            return Unit.Default;
-        }
+                return Task.CompletedTask;
+            });
+
+        _searchIndex.Commit();
+        return Unit.Default;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Emby/EmbyPathReplacementService.cs b/ErsatzTV.Core/Emby/EmbyPathReplacementService.cs
index abcf56688..443725283 100644
--- a/ErsatzTV.Core/Emby/EmbyPathReplacementService.cs
+++ b/ErsatzTV.Core/Emby/EmbyPathReplacementService.cs
@@ -1,89 +1,83 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Runtime;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Core.Emby
+namespace ErsatzTV.Core.Emby;
+
+public class EmbyPathReplacementService : IEmbyPathReplacementService
 {
-    public class EmbyPathReplacementService : IEmbyPathReplacementService
+    private readonly ILogger<EmbyPathReplacementService> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IRuntimeInfo _runtimeInfo;
+
+    public EmbyPathReplacementService(
+        IMediaSourceRepository mediaSourceRepository,
+        IRuntimeInfo runtimeInfo,
+        ILogger<EmbyPathReplacementService> logger)
     {
-        private readonly ILogger<EmbyPathReplacementService> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IRuntimeInfo _runtimeInfo;
-
-        public EmbyPathReplacementService(
-            IMediaSourceRepository mediaSourceRepository,
-            IRuntimeInfo runtimeInfo,
-            ILogger<EmbyPathReplacementService> logger)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _runtimeInfo = runtimeInfo;
-            _logger = logger;
-        }
-
-        public async Task<string> GetReplacementEmbyPath(int libraryPathId, string path)
-        {
-            List<EmbyPathReplacement> replacements =
-                await _mediaSourceRepository.GetEmbyPathReplacementsByLibraryId(libraryPathId);
-
-            return GetReplacementEmbyPath(replacements, path);
-        }
-
-        public string GetReplacementEmbyPath(
-            List<EmbyPathReplacement> pathReplacements,
-            string path,
-            bool log = true)
-        {
-            Option<EmbyPathReplacement> maybeReplacement = pathReplacements
-                .SingleOrDefault(
-                    r =>
-                    {
-                        string separatorChar = IsWindows(r.EmbyMediaSource, path) ? @"\" : @"/";
-                        string prefix = r.EmbyPath.EndsWith(separatorChar)
-                            ? r.EmbyPath
-                            : r.EmbyPath + separatorChar;
-                        return path.StartsWith(prefix);
-                    });
-
-            return maybeReplacement.Match(
-                replacement =>
-                {
-                    string finalPath = path.Replace(replacement.EmbyPath, replacement.LocalPath);
-                    if (IsWindows(replacement.EmbyMediaSource, path) && !_runtimeInfo.IsOSPlatform(OSPlatform.Windows))
-                    {
-                        finalPath = finalPath.Replace(@"\", @"/");
-                    }
-                    else if (!IsWindows(replacement.EmbyMediaSource, path) &&
-                             _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
-                    {
-                        finalPath = finalPath.Replace(@"/", @"\");
-                    }
-
-                    if (log)
-                    {
-                        _logger.LogInformation(
-                            "Replacing emby path {EmbyPath} with {LocalPath} resulting in {FinalPath}",
-                            replacement.EmbyPath,
-                            replacement.LocalPath,
-                            finalPath);
-                    }
-
-                    return finalPath;
-                },
-                () => path);
-        }
-
-        private static bool IsWindows(EmbyMediaSource embyMediaSource, string path)
-        {
-            bool isUnc = Uri.TryCreate(path, UriKind.Absolute, out Uri uri) && uri.IsUnc;
-            return isUnc || embyMediaSource.OperatingSystem.ToLowerInvariant().StartsWith("windows");
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _runtimeInfo = runtimeInfo;
+        _logger = logger;
     }
-}
+
+    public async Task<string> GetReplacementEmbyPath(int libraryPathId, string path)
+    {
+        List<EmbyPathReplacement> replacements =
+            await _mediaSourceRepository.GetEmbyPathReplacementsByLibraryId(libraryPathId);
+
+        return GetReplacementEmbyPath(replacements, path);
+    }
+
+    public string GetReplacementEmbyPath(
+        List<EmbyPathReplacement> pathReplacements,
+        string path,
+        bool log = true)
+    {
+        Option<EmbyPathReplacement> maybeReplacement = pathReplacements
+            .SingleOrDefault(
+                r =>
+                {
+                    string separatorChar = IsWindows(r.EmbyMediaSource, path) ? @"\" : @"/";
+                    string prefix = r.EmbyPath.EndsWith(separatorChar)
+                        ? r.EmbyPath
+                        : r.EmbyPath + separatorChar;
+                    return path.StartsWith(prefix);
+                });
+
+        return maybeReplacement.Match(
+            replacement =>
+            {
+                string finalPath = path.Replace(replacement.EmbyPath, replacement.LocalPath);
+                if (IsWindows(replacement.EmbyMediaSource, path) && !_runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                {
+                    finalPath = finalPath.Replace(@"\", @"/");
+                }
+                else if (!IsWindows(replacement.EmbyMediaSource, path) &&
+                         _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                {
+                    finalPath = finalPath.Replace(@"/", @"\");
+                }
+
+                if (log)
+                {
+                    _logger.LogInformation(
+                        "Replacing emby path {EmbyPath} with {LocalPath} resulting in {FinalPath}",
+                        replacement.EmbyPath,
+                        replacement.LocalPath,
+                        finalPath);
+                }
+
+                return finalPath;
+            },
+            () => path);
+    }
+
+    private static bool IsWindows(EmbyMediaSource embyMediaSource, string path)
+    {
+        bool isUnc = Uri.TryCreate(path, UriKind.Absolute, out Uri uri) && uri.IsUnc;
+        return isUnc || embyMediaSource.OperatingSystem.ToLowerInvariant().StartsWith("windows");
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Emby/EmbySecrets.cs b/ErsatzTV.Core/Emby/EmbySecrets.cs
index 9650fb00b..8fcfaee38 100644
--- a/ErsatzTV.Core/Emby/EmbySecrets.cs
+++ b/ErsatzTV.Core/Emby/EmbySecrets.cs
@@ -1,8 +1,7 @@
 using ErsatzTV.Core.MediaSources;
 
-namespace ErsatzTV.Core.Emby
+namespace ErsatzTV.Core.Emby;
+
+public class EmbySecrets : RemoteMediaSourceSecrets
 {
-    public class EmbySecrets : RemoteMediaSourceSecrets
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Emby/EmbyServerInformation.cs b/ErsatzTV.Core/Emby/EmbyServerInformation.cs
index 81d08d575..04c23e703 100644
--- a/ErsatzTV.Core/Emby/EmbyServerInformation.cs
+++ b/ErsatzTV.Core/Emby/EmbyServerInformation.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Core.Emby
-{
-    public record EmbyServerInformation(string ServerName, string OperatingSystem);
-}
+namespace ErsatzTV.Core.Emby;
+
+public record EmbyServerInformation(string ServerName, string OperatingSystem);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs b/ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs
index 87abc2920..9ca99db3b 100644
--- a/ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Emby/EmbyTelevisionLibraryScanner.cs
@@ -1,96 +1,305 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Emby
+namespace ErsatzTV.Core.Emby;
+
+public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
 {
-    public class EmbyTelevisionLibraryScanner : IEmbyTelevisionLibraryScanner
+    private readonly IEmbyApiClient _embyApiClient;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalStatisticsProvider _localStatisticsProvider;
+    private readonly ILogger<EmbyTelevisionLibraryScanner> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediator _mediator;
+    private readonly IEmbyPathReplacementService _pathReplacementService;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+    private readonly IEmbyTelevisionRepository _televisionRepository;
+
+    public EmbyTelevisionLibraryScanner(
+        IEmbyApiClient embyApiClient,
+        IMediaSourceRepository mediaSourceRepository,
+        IEmbyTelevisionRepository televisionRepository,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        IEmbyPathReplacementService pathReplacementService,
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        IMediator mediator,
+        ILogger<EmbyTelevisionLibraryScanner> logger)
     {
-        private readonly IEmbyApiClient _embyApiClient;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly ILogger<EmbyTelevisionLibraryScanner> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMediator _mediator;
-        private readonly IEmbyPathReplacementService _pathReplacementService;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
-        private readonly IEmbyTelevisionRepository _televisionRepository;
+        _embyApiClient = embyApiClient;
+        _mediaSourceRepository = mediaSourceRepository;
+        _televisionRepository = televisionRepository;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _pathReplacementService = pathReplacementService;
+        _localFileSystem = localFileSystem;
+        _localStatisticsProvider = localStatisticsProvider;
+        _mediator = mediator;
+        _logger = logger;
+    }
 
-        public EmbyTelevisionLibraryScanner(
-            IEmbyApiClient embyApiClient,
-            IMediaSourceRepository mediaSourceRepository,
-            IEmbyTelevisionRepository televisionRepository,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            IEmbyPathReplacementService pathReplacementService,
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            IMediator mediator,
-            ILogger<EmbyTelevisionLibraryScanner> logger)
+    public async Task<Either<BaseError, Unit>> ScanLibrary(
+        string address,
+        string apiKey,
+        EmbyLibrary library,
+        string ffprobePath)
+    {
+        List<EmbyItemEtag> existingShows = await _televisionRepository.GetExistingShows(library);
+
+        // TODO: maybe get quick list of item ids and etags from api to compare first
+        // TODO: paging?
+
+        List<EmbyPathReplacement> pathReplacements = await _mediaSourceRepository
+            .GetEmbyPathReplacements(library.MediaSourceId);
+
+        Either<BaseError, List<EmbyShow>> maybeShows = await _embyApiClient.GetShowLibraryItems(
+            address,
+            apiKey,
+            library.MediaSourceId,
+            library.ItemId);
+
+        await maybeShows.Match(
+            async shows =>
+            {
+                await ProcessShows(address, apiKey, library, ffprobePath, pathReplacements, existingShows, shows);
+
+                var incomingShowIds = shows.Map(s => s.ItemId).ToList();
+                var showIds = existingShows
+                    .Filter(i => !incomingShowIds.Contains(i.ItemId))
+                    .Map(m => m.ItemId)
+                    .ToList();
+                List<int> missingShowIds = await _televisionRepository.RemoveMissingShows(library, showIds);
+                await _searchIndex.RemoveItems(missingShowIds);
+
+                await _televisionRepository.DeleteEmptySeasons(library);
+                List<int> emptyShowIds = await _televisionRepository.DeleteEmptyShows(library);
+                await _searchIndex.RemoveItems(emptyShowIds);
+
+                await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+                _searchIndex.Commit();
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing emby library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
+
+                return Task.CompletedTask;
+            });
+
+        return Unit.Default;
+    }
+
+    private async Task ProcessShows(
+        string address,
+        string apiKey,
+        EmbyLibrary library,
+        string ffprobePath,
+        List<EmbyPathReplacement> pathReplacements,
+        List<EmbyItemEtag> existingShows,
+        List<EmbyShow> shows)
+    {
+        var sortedShows = shows.OrderBy(s => s.ShowMetadata.Head().Title).ToList();
+        foreach (EmbyShow incoming in sortedShows)
         {
-            _embyApiClient = embyApiClient;
-            _mediaSourceRepository = mediaSourceRepository;
-            _televisionRepository = televisionRepository;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _pathReplacementService = pathReplacementService;
-            _localFileSystem = localFileSystem;
-            _localStatisticsProvider = localStatisticsProvider;
-            _mediator = mediator;
-            _logger = logger;
-        }
+            decimal percentCompletion = (decimal) sortedShows.IndexOf(incoming) / shows.Count;
+            await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
 
-        public async Task<Either<BaseError, Unit>> ScanLibrary(
-            string address,
-            string apiKey,
-            EmbyLibrary library,
-            string ffprobePath)
-        {
-            List<EmbyItemEtag> existingShows = await _televisionRepository.GetExistingShows(library);
-
-            // TODO: maybe get quick list of item ids and etags from api to compare first
-            // TODO: paging?
-
-            List<EmbyPathReplacement> pathReplacements = await _mediaSourceRepository
-                .GetEmbyPathReplacements(library.MediaSourceId);
-
-            Either<BaseError, List<EmbyShow>> maybeShows = await _embyApiClient.GetShowLibraryItems(
-                address,
-                apiKey,
-                library.MediaSourceId,
-                library.ItemId);
-
-            await maybeShows.Match(
-                async shows =>
+            Option<EmbyItemEtag> maybeExisting = existingShows.Find(ie => ie.ItemId == incoming.ItemId);
+            await maybeExisting.Match(
+                async existing =>
                 {
-                    await ProcessShows(address, apiKey, library, ffprobePath, pathReplacements, existingShows, shows);
+                    if (existing.Etag == incoming.Etag)
+                    {
+                        return;
+                    }
 
-                    var incomingShowIds = shows.Map(s => s.ItemId).ToList();
-                    var showIds = existingShows
-                        .Filter(i => !incomingShowIds.Contains(i.ItemId))
+                    _logger.LogDebug(
+                        "UPDATE: Etag has changed for show {Show}",
+                        incoming.ShowMetadata.Head().Title);
+
+                    incoming.LibraryPathId = library.Paths.Head().Id;
+
+                    Option<EmbyShow> updated = await _televisionRepository.Update(incoming);
+                    if (updated.IsSome)
+                    {
+                        await _searchIndex.UpdateItems(
+                            _searchRepository,
+                            new List<MediaItem> { updated.ValueUnsafe() });
+                    }
+                },
+                async () =>
+                {
+                    incoming.LibraryPathId = library.Paths.Head().Id;
+
+                    // _logger.LogDebug("INSERT: Item id is new for show {Show}", incoming.ShowMetadata.Head().Title);
+
+                    if (await _televisionRepository.AddShow(incoming))
+                    {
+                        await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
+                    }
+                });
+
+            List<EmbyItemEtag> existingSeasons =
+                await _televisionRepository.GetExistingSeasons(library, incoming.ItemId);
+
+            Either<BaseError, List<EmbySeason>> maybeSeasons =
+                await _embyApiClient.GetSeasonLibraryItems(
+                    address,
+                    apiKey,
+                    library.MediaSourceId,
+                    incoming.ItemId);
+
+            await maybeSeasons.Match(
+                async seasons =>
+                {
+                    await ProcessSeasons(
+                        address,
+                        apiKey,
+                        library,
+                        ffprobePath,
+                        pathReplacements,
+                        incoming,
+                        existingSeasons,
+                        seasons);
+
+                    var incomingSeasonIds = seasons.Map(s => s.ItemId).ToList();
+                    var seasonIds = existingSeasons
+                        .Filter(i => !incomingSeasonIds.Contains(i.ItemId))
                         .Map(m => m.ItemId)
                         .ToList();
-                    List<int> missingShowIds = await _televisionRepository.RemoveMissingShows(library, showIds);
-                    await _searchIndex.RemoveItems(missingShowIds);
+                    await _televisionRepository.RemoveMissingSeasons(library, seasonIds);
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Error synchronizing emby library {Path}: {Error}",
+                        library.Name,
+                        error.Value);
 
-                    await _televisionRepository.DeleteEmptySeasons(library);
-                    List<int> emptyShowIds = await _televisionRepository.DeleteEmptyShows(library);
-                    await _searchIndex.RemoveItems(emptyShowIds);
+                    return Task.CompletedTask;
+                });
+        }
+    }
 
-                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+    private async Task ProcessSeasons(
+        string address,
+        string apiKey,
+        EmbyLibrary library,
+        string ffprobePath,
+        List<EmbyPathReplacement> pathReplacements,
+        EmbyShow show,
+        List<EmbyItemEtag> existingSeasons,
+        List<EmbySeason> seasons)
+    {
+        foreach (EmbySeason incoming in seasons)
+        {
+            Option<EmbyItemEtag> maybeExisting = existingSeasons.Find(ie => ie.ItemId == incoming.ItemId);
+            await maybeExisting.Match(
+                async existing =>
+                {
+                    if (existing.Etag == incoming.Etag)
+                    {
+                        return;
+                    }
+
+                    _logger.LogDebug(
+                        "UPDATE: Etag has changed for show {Show} season {Season}",
+                        show.ShowMetadata.Head().Title,
+                        incoming.SeasonMetadata.Head().Title);
+
+                    incoming.ShowId = show.Id;
+                    incoming.LibraryPathId = library.Paths.Head().Id;
+
+                    foreach (EmbySeason updated in await _televisionRepository.Update(incoming))
+                    {
+                        incoming.Show = show;
+                            
+                        foreach (MediaItem toIndex in await _searchRepository.GetItemToIndex(updated.Id))
+                        {
+                            await _searchIndex.UpdateItems(
+                                _searchRepository,
+                                new List<MediaItem> { toIndex });
+                        }
+                    }
+                },
+                async () =>
+                {
+                    incoming.LibraryPathId = library.Paths.Head().Id;
+
+                    _logger.LogDebug(
+                        "INSERT: Item id is new for show {Show} season {Season}",
+                        show.ShowMetadata.Head().Title,
+                        incoming.SeasonMetadata.Head().Title);
+
+                    if (await _televisionRepository.AddSeason(show, incoming))
+                    {
+                        incoming.Show = show;
+                        await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
+                    }
+                });
+
+            List<EmbyItemEtag> existingEpisodes =
+                await _televisionRepository.GetExistingEpisodes(library, incoming.ItemId);
+
+            Either<BaseError, List<EmbyEpisode>> maybeEpisodes =
+                await _embyApiClient.GetEpisodeLibraryItems(
+                    address,
+                    apiKey,
+                    library.MediaSourceId,
+                    incoming.ItemId);
+
+            await maybeEpisodes.Match(
+                async episodes =>
+                {
+                    var validEpisodes = new List<EmbyEpisode>();
+                    foreach (EmbyEpisode episode in episodes)
+                    {
+                        string localPath = _pathReplacementService.GetReplacementEmbyPath(
+                            pathReplacements,
+                            episode.MediaVersions.Head().MediaFiles.Head().Path,
+                            false);
+
+                        if (!_localFileSystem.FileExists(localPath))
+                        {
+                            _logger.LogWarning(
+                                "Skipping emby episode that does not exist at {Path}",
+                                localPath);
+                        }
+                        else
+                        {
+                            validEpisodes.Add(episode);
+                        }
+                    }
+
+                    await ProcessEpisodes(
+                        show.ShowMetadata.Head().Title,
+                        incoming.SeasonMetadata.Head().Title,
+                        library,
+                        ffprobePath,
+                        pathReplacements,
+                        incoming,
+                        existingEpisodes,
+                        validEpisodes);
+
+                    var incomingEpisodeIds = episodes.Map(s => s.ItemId).ToList();
+                    var episodeIds = existingEpisodes
+                        .Filter(i => !incomingEpisodeIds.Contains(i.ItemId))
+                        .Map(m => m.ItemId)
+                        .ToList();
+                    List<int> missingEpisodeIds =
+                        await _televisionRepository.RemoveMissingEpisodes(library, episodeIds);
+                    await _searchIndex.RemoveItems(missingEpisodeIds);
                     _searchIndex.Commit();
                 },
                 error =>
@@ -102,28 +311,29 @@ namespace ErsatzTV.Core.Emby
 
                     return Task.CompletedTask;
                 });
-
-            return Unit.Default;
         }
+    }
 
-        private async Task ProcessShows(
-            string address,
-            string apiKey,
-            EmbyLibrary library,
-            string ffprobePath,
-            List<EmbyPathReplacement> pathReplacements,
-            List<EmbyItemEtag> existingShows,
-            List<EmbyShow> shows)
+    private async Task ProcessEpisodes(
+        string showName,
+        string seasonName,
+        EmbyLibrary library,
+        string ffprobePath,
+        List<EmbyPathReplacement> pathReplacements,
+        EmbySeason season,
+        List<EmbyItemEtag> existingEpisodes,
+        List<EmbyEpisode> episodes)
+    {
+        foreach (EmbyEpisode incoming in episodes)
         {
-            var sortedShows = shows.OrderBy(s => s.ShowMetadata.Head().Title).ToList();
-            foreach (EmbyShow incoming in sortedShows)
-            {
-                decimal percentCompletion = (decimal) sortedShows.IndexOf(incoming) / shows.Count;
-                await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
+            EmbyEpisode incomingEpisode = incoming;
+            var updateStatistics = false;
 
-                Option<EmbyItemEtag> maybeExisting = existingShows.Find(ie => ie.ItemId == incoming.ItemId);
-                await maybeExisting.Match(
-                    async existing =>
+            Option<EmbyItemEtag> maybeExisting = existingEpisodes.Find(ie => ie.ItemId == incoming.ItemId);
+            await maybeExisting.Match(
+                async existing =>
+                {
+                    try
                     {
                         if (existing.Etag == incoming.Etag)
                         {
@@ -131,298 +341,81 @@ namespace ErsatzTV.Core.Emby
                         }
 
                         _logger.LogDebug(
-                            "UPDATE: Etag has changed for show {Show}",
-                            incoming.ShowMetadata.Head().Title);
+                            "UPDATE: Etag has changed for show {Show} season {Season} episode {Episode}",
+                            showName,
+                            seasonName,
+                            incoming.EpisodeMetadata.HeadOrNone().Map(em => em.EpisodeNumber));
 
+                        updateStatistics = true;
+                        incoming.SeasonId = season.Id;
                         incoming.LibraryPathId = library.Paths.Head().Id;
 
-                        Option<EmbyShow> updated = await _televisionRepository.Update(incoming);
-                        if (updated.IsSome)
+                        Option<EmbyEpisode> maybeUpdated = await _televisionRepository.Update(incoming);
+                        foreach (EmbyEpisode updated in maybeUpdated)
                         {
                             await _searchIndex.UpdateItems(
                                 _searchRepository,
-                                new List<MediaItem> { updated.ValueUnsafe() });
+                                new List<MediaItem> { updated });
+
+                            incomingEpisode = updated;
                         }
-                    },
-                    async () =>
+                    }
+                    catch (Exception ex)
                     {
-                        incoming.LibraryPathId = library.Paths.Head().Id;
-
-                        // _logger.LogDebug("INSERT: Item id is new for show {Show}", incoming.ShowMetadata.Head().Title);
-
-                        if (await _televisionRepository.AddShow(incoming))
-                        {
-                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
-                        }
-                    });
-
-                List<EmbyItemEtag> existingSeasons =
-                    await _televisionRepository.GetExistingSeasons(library, incoming.ItemId);
-
-                Either<BaseError, List<EmbySeason>> maybeSeasons =
-                    await _embyApiClient.GetSeasonLibraryItems(
-                        address,
-                        apiKey,
-                        library.MediaSourceId,
-                        incoming.ItemId);
-
-                await maybeSeasons.Match(
-                    async seasons =>
-                    {
-                        await ProcessSeasons(
-                            address,
-                            apiKey,
-                            library,
-                            ffprobePath,
-                            pathReplacements,
-                            incoming,
-                            existingSeasons,
-                            seasons);
-
-                        var incomingSeasonIds = seasons.Map(s => s.ItemId).ToList();
-                        var seasonIds = existingSeasons
-                            .Filter(i => !incomingSeasonIds.Contains(i.ItemId))
-                            .Map(m => m.ItemId)
-                            .ToList();
-                        await _televisionRepository.RemoveMissingSeasons(library, seasonIds);
-                    },
-                    error =>
-                    {
-                        _logger.LogWarning(
-                            "Error synchronizing emby library {Path}: {Error}",
-                            library.Name,
-                            error.Value);
-
-                        return Task.CompletedTask;
-                    });
-            }
-        }
-
-        private async Task ProcessSeasons(
-            string address,
-            string apiKey,
-            EmbyLibrary library,
-            string ffprobePath,
-            List<EmbyPathReplacement> pathReplacements,
-            EmbyShow show,
-            List<EmbyItemEtag> existingSeasons,
-            List<EmbySeason> seasons)
-        {
-            foreach (EmbySeason incoming in seasons)
-            {
-                Option<EmbyItemEtag> maybeExisting = existingSeasons.Find(ie => ie.ItemId == incoming.ItemId);
-                await maybeExisting.Match(
-                    async existing =>
-                    {
-                        if (existing.Etag == incoming.Etag)
-                        {
-                            return;
-                        }
-
-                        _logger.LogDebug(
-                            "UPDATE: Etag has changed for show {Show} season {Season}",
-                            show.ShowMetadata.Head().Title,
-                            incoming.SeasonMetadata.Head().Title);
-
-                        incoming.ShowId = show.Id;
-                        incoming.LibraryPathId = library.Paths.Head().Id;
-
-                        foreach (EmbySeason updated in await _televisionRepository.Update(incoming))
-                        {
-                            incoming.Show = show;
-                            
-                            foreach (MediaItem toIndex in await _searchRepository.GetItemToIndex(updated.Id))
-                            {
-                                await _searchIndex.UpdateItems(
-                                    _searchRepository,
-                                    new List<MediaItem> { toIndex });
-                            }
-                        }
-                    },
-                    async () =>
-                    {
-                        incoming.LibraryPathId = library.Paths.Head().Id;
-
-                        _logger.LogDebug(
-                            "INSERT: Item id is new for show {Show} season {Season}",
-                            show.ShowMetadata.Head().Title,
-                            incoming.SeasonMetadata.Head().Title);
-
-                        if (await _televisionRepository.AddSeason(show, incoming))
-                        {
-                            incoming.Show = show;
-                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
-                        }
-                    });
-
-                List<EmbyItemEtag> existingEpisodes =
-                    await _televisionRepository.GetExistingEpisodes(library, incoming.ItemId);
-
-                Either<BaseError, List<EmbyEpisode>> maybeEpisodes =
-                    await _embyApiClient.GetEpisodeLibraryItems(
-                        address,
-                        apiKey,
-                        library.MediaSourceId,
-                        incoming.ItemId);
-
-                await maybeEpisodes.Match(
-                    async episodes =>
-                    {
-                        var validEpisodes = new List<EmbyEpisode>();
-                        foreach (EmbyEpisode episode in episodes)
-                        {
-                            string localPath = _pathReplacementService.GetReplacementEmbyPath(
-                                pathReplacements,
-                                episode.MediaVersions.Head().MediaFiles.Head().Path,
-                                false);
-
-                            if (!_localFileSystem.FileExists(localPath))
-                            {
-                                _logger.LogWarning(
-                                    "Skipping emby episode that does not exist at {Path}",
-                                    localPath);
-                            }
-                            else
-                            {
-                                validEpisodes.Add(episode);
-                            }
-                        }
-
-                        await ProcessEpisodes(
-                            show.ShowMetadata.Head().Title,
-                            incoming.SeasonMetadata.Head().Title,
-                            library,
-                            ffprobePath,
-                            pathReplacements,
-                            incoming,
-                            existingEpisodes,
-                            validEpisodes);
-
-                        var incomingEpisodeIds = episodes.Map(s => s.ItemId).ToList();
-                        var episodeIds = existingEpisodes
-                            .Filter(i => !incomingEpisodeIds.Contains(i.ItemId))
-                            .Map(m => m.ItemId)
-                            .ToList();
-                        List<int> missingEpisodeIds =
-                            await _televisionRepository.RemoveMissingEpisodes(library, episodeIds);
-                        await _searchIndex.RemoveItems(missingEpisodeIds);
-                        _searchIndex.Commit();
-                    },
-                    error =>
-                    {
-                        _logger.LogWarning(
-                            "Error synchronizing emby library {Path}: {Error}",
-                            library.Name,
-                            error.Value);
-
-                        return Task.CompletedTask;
-                    });
-            }
-        }
-
-        private async Task ProcessEpisodes(
-            string showName,
-            string seasonName,
-            EmbyLibrary library,
-            string ffprobePath,
-            List<EmbyPathReplacement> pathReplacements,
-            EmbySeason season,
-            List<EmbyItemEtag> existingEpisodes,
-            List<EmbyEpisode> episodes)
-        {
-            foreach (EmbyEpisode incoming in episodes)
-            {
-                EmbyEpisode incomingEpisode = incoming;
-                var updateStatistics = false;
-
-                Option<EmbyItemEtag> maybeExisting = existingEpisodes.Find(ie => ie.ItemId == incoming.ItemId);
-                await maybeExisting.Match(
-                    async existing =>
-                    {
-                        try
-                        {
-                            if (existing.Etag == incoming.Etag)
-                            {
-                                return;
-                            }
-
-                            _logger.LogDebug(
-                                "UPDATE: Etag has changed for show {Show} season {Season} episode {Episode}",
-                                showName,
-                                seasonName,
-                                incoming.EpisodeMetadata.HeadOrNone().Map(em => em.EpisodeNumber));
-
-                            updateStatistics = true;
-                            incoming.SeasonId = season.Id;
-                            incoming.LibraryPathId = library.Paths.Head().Id;
-
-                            Option<EmbyEpisode> maybeUpdated = await _televisionRepository.Update(incoming);
-                            foreach (EmbyEpisode updated in maybeUpdated)
-                            {
-                                await _searchIndex.UpdateItems(
-                                    _searchRepository,
-                                    new List<MediaItem> { updated });
-
-                                incomingEpisode = updated;
-                            }
-                        }
-                        catch (Exception ex)
-                        {
-                            updateStatistics = false;
-                            _logger.LogError(
-                                ex,
-                                "Error updating episode {Path}",
-                                incoming.MediaVersions.Head().MediaFiles.Head().Path);
-                        }
-                    },
-                    async () =>
-                    {
-                        try
-                        {
-                            updateStatistics = true;
-                            incoming.LibraryPathId = library.Paths.Head().Id;
-
-                            _logger.LogDebug(
-                                "INSERT: Item id is new for show {Show} season {Season} episode {Episode}",
-                                showName,
-                                seasonName,
-                                incoming.EpisodeMetadata.HeadOrNone().Map(em => em.EpisodeNumber));
-
-                            if (await _televisionRepository.AddEpisode(season, incoming))
-                            {
-                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
-                            }
-                        }
-                        catch (Exception ex)
-                        {
-                            updateStatistics = false;
-                            _logger.LogError(
-                                ex,
-                                "Error adding episode {Path}",
-                                incoming.MediaVersions.Head().MediaFiles.Head().Path);
-                        }
-                    });
-
-                if (updateStatistics)
+                        updateStatistics = false;
+                        _logger.LogError(
+                            ex,
+                            "Error updating episode {Path}",
+                            incoming.MediaVersions.Head().MediaFiles.Head().Path);
+                    }
+                },
+                async () =>
                 {
-                    string localPath = _pathReplacementService.GetReplacementEmbyPath(
-                        pathReplacements,
-                        incoming.MediaVersions.Head().MediaFiles.Head().Path,
-                        false);
+                    try
+                    {
+                        updateStatistics = true;
+                        incoming.LibraryPathId = library.Paths.Head().Id;
 
-                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
-                    Either<BaseError, bool> refreshResult =
-                        await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingEpisode, localPath);
+                        _logger.LogDebug(
+                            "INSERT: Item id is new for show {Show} season {Season} episode {Episode}",
+                            showName,
+                            seasonName,
+                            incoming.EpisodeMetadata.HeadOrNone().Map(em => em.EpisodeNumber));
 
-                    refreshResult.Match(
-                        _ => { },
-                        error => _logger.LogWarning(
-                            "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                            "Statistics",
-                            localPath,
-                            error.Value));
-                }
+                        if (await _televisionRepository.AddEpisode(season, incoming))
+                        {
+                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        updateStatistics = false;
+                        _logger.LogError(
+                            ex,
+                            "Error adding episode {Path}",
+                            incoming.MediaVersions.Head().MediaFiles.Head().Path);
+                    }
+                });
+
+            if (updateStatistics)
+            {
+                string localPath = _pathReplacementService.GetReplacementEmbyPath(
+                    pathReplacements,
+                    incoming.MediaVersions.Head().MediaFiles.Head().Path,
+                    false);
+
+                _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
+                Either<BaseError, bool> refreshResult =
+                    await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingEpisode, localPath);
+
+                refreshResult.Match(
+                    _ => { },
+                    error => _logger.LogWarning(
+                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                        "Statistics",
+                        localPath,
+                        error.Value));
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Emby/EmbyUrl.cs b/ErsatzTV.Core/Emby/EmbyUrl.cs
index e72e8b8b4..9d4718043 100644
--- a/ErsatzTV.Core/Emby/EmbyUrl.cs
+++ b/ErsatzTV.Core/Emby/EmbyUrl.cs
@@ -1,83 +1,81 @@
 using ErsatzTV.Core.Domain;
 using Flurl;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Emby
+namespace ErsatzTV.Core.Emby;
+
+public static class EmbyUrl
 {
-    public static class EmbyUrl
+    public static Url ForArtwork(Option<EmbyMediaSource> maybeEmby, string artwork)
     {
-        public static Url ForArtwork(Option<EmbyMediaSource> maybeEmby, string artwork)
+        string address = maybeEmby.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
+            .Flatten()
+            .IfNone("emby://");
+
+        string[] split = artwork.Replace("emby://", string.Empty).Split('?');
+        if (split.Length != 2)
         {
-            string address = maybeEmby.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
-                .Flatten()
-                .IfNone("emby://");
-
-            string[] split = artwork.Replace("emby://", string.Empty).Split('?');
-            if (split.Length != 2)
-            {
-                return artwork;
-            }
-
-            string pathSegment = split[0];
-            QueryParamCollection query = Url.ParseQueryParams(split[1]);
-
-            return Url.Parse(address)
-                .AppendPathSegment(pathSegment)
-                .SetQueryParams(query);
+            return artwork;
         }
 
-        public static Url ForArtwork(string address, string artwork)
-        {
-            string[] split = artwork.Replace("emby://", string.Empty).Split('?');
-            if (split.Length != 2)
-            {
-                return artwork;
-            }
+        string pathSegment = split[0];
+        QueryParamCollection query = Url.ParseQueryParams(split[1]);
 
-            string pathSegment = split[0];
-            QueryParamCollection query = Url.ParseQueryParams(split[1]);
-
-            return Url.Parse(address)
-                .AppendPathSegment(pathSegment)
-                .SetQueryParams(query);
-        }
-
-        public static Url ProxyForArtwork(string scheme, string host, string artwork, ArtworkKind artworkKind)
-        {
-            string[] split = artwork.Replace("emby://", string.Empty).Split('?');
-            if (split.Length != 2)
-            {
-                return artwork;
-            }
-
-            string pathSegment = split[0];
-            QueryParamCollection query = Url.ParseQueryParams(split[1]);
-
-            string artworkFolder = artworkKind switch
-            {
-                ArtworkKind.Thumbnail => "thumbnails",
-                _ => "posters"
-            };
-
-            return Url.Parse($"{scheme}://{host}/iptv/artwork/{artworkFolder}/emby")
-                .AppendPathSegment(pathSegment)
-                .SetQueryParams(query);
-        }
-        
-        public static Url RelativeProxyForArtwork(string artwork)
-        {
-            string[] split = artwork.Replace("emby://", string.Empty).Split('?');
-            if (split.Length != 2)
-            {
-                return artwork;
-            }
-
-            string pathSegment = split[0];
-            QueryParamCollection query = Url.ParseQueryParams(split[1]);
-
-            return Url.Parse("emby")
-                .AppendPathSegment(pathSegment)
-                .SetQueryParams(query);
-        }
+        return Url.Parse(address)
+            .AppendPathSegment(pathSegment)
+            .SetQueryParams(query);
     }
-}
+
+    public static Url ForArtwork(string address, string artwork)
+    {
+        string[] split = artwork.Replace("emby://", string.Empty).Split('?');
+        if (split.Length != 2)
+        {
+            return artwork;
+        }
+
+        string pathSegment = split[0];
+        QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+        return Url.Parse(address)
+            .AppendPathSegment(pathSegment)
+            .SetQueryParams(query);
+    }
+
+    public static Url ProxyForArtwork(string scheme, string host, string artwork, ArtworkKind artworkKind)
+    {
+        string[] split = artwork.Replace("emby://", string.Empty).Split('?');
+        if (split.Length != 2)
+        {
+            return artwork;
+        }
+
+        string pathSegment = split[0];
+        QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+        string artworkFolder = artworkKind switch
+        {
+            ArtworkKind.Thumbnail => "thumbnails",
+            _ => "posters"
+        };
+
+        return Url.Parse($"{scheme}://{host}/iptv/artwork/{artworkFolder}/emby")
+            .AppendPathSegment(pathSegment)
+            .SetQueryParams(query);
+    }
+        
+    public static Url RelativeProxyForArtwork(string artwork)
+    {
+        string[] split = artwork.Replace("emby://", string.Empty).Split('?');
+        if (split.Length != 2)
+        {
+            return artwork;
+        }
+
+        string pathSegment = split[0];
+        QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+        return Url.Parse("emby")
+            .AppendPathSegment(pathSegment)
+            .SetQueryParams(query);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Errors/ChannelSessionAlreadyActive.cs b/ErsatzTV.Core/Errors/ChannelSessionAlreadyActive.cs
index c0cfdbb08..d88fb7dde 100644
--- a/ErsatzTV.Core/Errors/ChannelSessionAlreadyActive.cs
+++ b/ErsatzTV.Core/Errors/ChannelSessionAlreadyActive.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Core.Errors
+namespace ErsatzTV.Core.Errors;
+
+public class ChannelSessionAlreadyActive : BaseError
 {
-    public class ChannelSessionAlreadyActive : BaseError
+    public ChannelSessionAlreadyActive() : base("Channel already has HLS session")
     {
-        public ChannelSessionAlreadyActive() : base("Channel already has HLS session")
-        {
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Errors/MediaSourceRecentlyScanned.cs b/ErsatzTV.Core/Errors/MediaSourceRecentlyScanned.cs
index 6342c54f1..1930f21ed 100644
--- a/ErsatzTV.Core/Errors/MediaSourceRecentlyScanned.cs
+++ b/ErsatzTV.Core/Errors/MediaSourceRecentlyScanned.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.Errors
+namespace ErsatzTV.Core.Errors;
+
+public class MediaSourceRecentlyScanned : BaseError
 {
-    public class MediaSourceRecentlyScanned : BaseError
+    public MediaSourceRecentlyScanned(string folder) :
+        base($"Media source {folder} was already scanned recently; skipping scan.")
     {
-        public MediaSourceRecentlyScanned(string folder) :
-            base($"Media source {folder} was already scanned recently; skipping scan.")
-        {
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Errors/PlayoutItemDoesNotExistOnDisk.cs b/ErsatzTV.Core/Errors/PlayoutItemDoesNotExistOnDisk.cs
index cea5e62a8..fc15c299b 100644
--- a/ErsatzTV.Core/Errors/PlayoutItemDoesNotExistOnDisk.cs
+++ b/ErsatzTV.Core/Errors/PlayoutItemDoesNotExistOnDisk.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Core.Errors
+namespace ErsatzTV.Core.Errors;
+
+public class PlayoutItemDoesNotExistOnDisk : BaseError
 {
-    public class PlayoutItemDoesNotExistOnDisk : BaseError
+    public PlayoutItemDoesNotExistOnDisk(string path) : base($"Playout item does not exist on disk\n{path}")
     {
-        public PlayoutItemDoesNotExistOnDisk(string path) : base($"Playout item does not exist on disk\n{path}")
-        {
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Errors/UnableToLocatePlayoutItem.cs b/ErsatzTV.Core/Errors/UnableToLocatePlayoutItem.cs
index a21035828..1014c363b 100644
--- a/ErsatzTV.Core/Errors/UnableToLocatePlayoutItem.cs
+++ b/ErsatzTV.Core/Errors/UnableToLocatePlayoutItem.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Core.Errors
+namespace ErsatzTV.Core.Errors;
+
+public class UnableToLocatePlayoutItem : BaseError
 {
-    public class UnableToLocatePlayoutItem : BaseError
+    public UnableToLocatePlayoutItem() : base("Unable to locate playout item")
     {
-        public UnableToLocatePlayoutItem() : base("Unable to locate playout item")
-        {
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/ErsatzTV.Core.csproj b/ErsatzTV.Core/ErsatzTV.Core.csproj
index b9e204c49..caa720d1d 100644
--- a/ErsatzTV.Core/ErsatzTV.Core.csproj
+++ b/ErsatzTV.Core/ErsatzTV.Core.csproj
@@ -3,6 +3,7 @@
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
         <NoWarn>VSTHRD200</NoWarn>
+        <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/ErsatzTV.Core/Extensions/MediaItemExtensions.cs b/ErsatzTV.Core/Extensions/MediaItemExtensions.cs
index 9053784b7..6f199678b 100644
--- a/ErsatzTV.Core/Extensions/MediaItemExtensions.cs
+++ b/ErsatzTV.Core/Extensions/MediaItemExtensions.cs
@@ -1,19 +1,17 @@
-using System;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Extensions
+namespace ErsatzTV.Core.Extensions;
+
+public static class MediaItemExtensions
 {
-    public static class MediaItemExtensions
-    {
-        public static MediaVersion GetHeadVersion(this MediaItem mediaItem) =>
-            mediaItem switch
-            {
-                Movie m => m.MediaVersions.Head(),
-                Episode e => e.MediaVersions.Head(),
-                MusicVideo mv => mv.MediaVersions.Head(),
-                OtherVideo ov => ov.MediaVersions.Head(),
-                Song s => s.MediaVersions.Head(),
-                _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
-            };
-    }
-}
+    public static MediaVersion GetHeadVersion(this MediaItem mediaItem) =>
+        mediaItem switch
+        {
+            Movie m => m.MediaVersions.Head(),
+            Episode e => e.MediaVersions.Head(),
+            MusicVideo mv => mv.MediaVersions.Head(),
+            OtherVideo ov => ov.MediaVersions.Head(),
+            Song s => s.MediaVersions.Head(),
+            _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
+        };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/ConcatPlaylist.cs b/ErsatzTV.Core/FFmpeg/ConcatPlaylist.cs
index 210250cc9..35a8850ba 100644
--- a/ErsatzTV.Core/FFmpeg/ConcatPlaylist.cs
+++ b/ErsatzTV.Core/FFmpeg/ConcatPlaylist.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public record ConcatPlaylist(string Scheme, string Host, string ChannelNumber)
 {
-    public record ConcatPlaylist(string Scheme, string Host, string ChannelNumber)
-    {
-        public override string ToString() =>
-            $@"ffconcat version 1.0
+    public override string ToString() =>
+        $@"ffconcat version 1.0
 file http://localhost:{Settings.ListenPort}/ffmpeg/stream/{ChannelNumber}?mode=ts-legacy
 file http://localhost:{Settings.ListenPort}/ffmpeg/stream/{ChannelNumber}?mode=ts-legacy";
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/DisplaySize.cs b/ErsatzTV.Core/FFmpeg/DisplaySize.cs
index 1613fea93..0f90964f0 100644
--- a/ErsatzTV.Core/FFmpeg/DisplaySize.cs
+++ b/ErsatzTV.Core/FFmpeg/DisplaySize.cs
@@ -1,6 +1,5 @@
 using ErsatzTV.Core.Interfaces.FFmpeg;
 
-namespace ErsatzTV.Core.FFmpeg
-{
-    internal record DisplaySize(int Width, int Height) : IDisplaySize;
-}
+namespace ErsatzTV.Core.FFmpeg;
+
+internal record DisplaySize(int Width, int Height) : IDisplaySize;
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/DisplaySizeExtensions.cs b/ErsatzTV.Core/FFmpeg/DisplaySizeExtensions.cs
index 9bfc8a8b8..253e25bed 100644
--- a/ErsatzTV.Core/FFmpeg/DisplaySizeExtensions.cs
+++ b/ErsatzTV.Core/FFmpeg/DisplaySizeExtensions.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.Core.Interfaces.FFmpeg;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public static class DisplaySizeExtensions
 {
-    public static class DisplaySizeExtensions
-    {
-        internal static bool IsSameSizeAs(this IDisplaySize @this, IDisplaySize that) =>
-            @this.Width == that.Width && @this.Height == that.Height;
-    }
-}
+    internal static bool IsSameSizeAs(this IDisplaySize @this, IDisplaySize that) =>
+        @this.Width == that.Width && @this.Height == that.Height;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegComplexFilter.cs b/ErsatzTV.Core/FFmpeg/FFmpegComplexFilter.cs
index c95609b1a..cb6dc8007 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegComplexFilter.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegComplexFilter.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Core.FFmpeg
-{
-    public record FFmpegComplexFilter(string ComplexFilter, string VideoLabel, string AudioLabel, string PixelFormat);
-}
+namespace ErsatzTV.Core.FFmpeg;
+
+public record FFmpegComplexFilter(string ComplexFilter, string VideoLabel, string AudioLabel, string PixelFormat);
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegComplexFilterBuilder.cs b/ErsatzTV.Core/FFmpeg/FFmpegComplexFilterBuilder.cs
index 1fe340536..e97c751c6 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegComplexFilterBuilder.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegComplexFilterBuilder.cs
@@ -1,567 +1,561 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using System.Runtime.InteropServices;
 using System.Text;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class FFmpegComplexFilterBuilder
 {
-    public class FFmpegComplexFilterBuilder
+    private Option<TimeSpan> _audioDuration = None;
+    private bool _deinterlace;
+    private Option<HardwareAccelerationKind> _hardwareAccelerationKind = None;
+    private string _inputCodec;
+    private bool _normalizeLoudness;
+    private Option<IDisplaySize> _padToSize = None;
+    private IDisplaySize _resolution;
+    private Option<IDisplaySize> _scaleToSize = None;
+    private Option<ChannelWatermark> _watermark;
+    private Option<List<FadePoint>> _maybeFadePoints = None;
+    private Option<int> _watermarkIndex;
+    private string _pixelFormat;
+    private string _videoDecoder;
+    private string _videoEncoder;
+    private Option<string> _subtitle;
+    private bool _boxBlur;
+
+    public FFmpegComplexFilterBuilder WithHardwareAcceleration(HardwareAccelerationKind hardwareAccelerationKind)
     {
-        private Option<TimeSpan> _audioDuration = None;
-        private bool _deinterlace;
-        private Option<HardwareAccelerationKind> _hardwareAccelerationKind = None;
-        private string _inputCodec;
-        private bool _normalizeLoudness;
-        private Option<IDisplaySize> _padToSize = None;
-        private IDisplaySize _resolution;
-        private Option<IDisplaySize> _scaleToSize = None;
-        private Option<ChannelWatermark> _watermark;
-        private Option<List<FadePoint>> _maybeFadePoints = None;
-        private Option<int> _watermarkIndex;
-        private string _pixelFormat;
-        private string _videoDecoder;
-        private string _videoEncoder;
-        private Option<string> _subtitle;
-        private bool _boxBlur;
+        _hardwareAccelerationKind = Some(hardwareAccelerationKind);
+        return this;
+    }
 
-        public FFmpegComplexFilterBuilder WithHardwareAcceleration(HardwareAccelerationKind hardwareAccelerationKind)
+    public FFmpegComplexFilterBuilder WithScaling(IDisplaySize scaleToSize)
+    {
+        _scaleToSize = Some(scaleToSize);
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithBlackBars(IDisplaySize padToSize)
+    {
+        _padToSize = Some(padToSize);
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithDeinterlace(bool deinterlace)
+    {
+        _deinterlace = deinterlace;
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithAlignedAudio(Option<TimeSpan> audioDuration)
+    {
+        _audioDuration = audioDuration;
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithNormalizeLoudness(bool normalizeLoudness)
+    {
+        _normalizeLoudness = normalizeLoudness;
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithInputCodec(Option<string> maybeCodec)
+    {
+        foreach (string codec in maybeCodec)
         {
-            _hardwareAccelerationKind = Some(hardwareAccelerationKind);
-            return this;
+            _inputCodec = codec;
         }
 
-        public FFmpegComplexFilterBuilder WithScaling(IDisplaySize scaleToSize)
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithDecoder(string decoder)
+    {
+        _videoDecoder = decoder;
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithInputPixelFormat(Option<string> maybePixelFormat)
+    {
+        foreach (string pixelFormat in maybePixelFormat)
         {
-            _scaleToSize = Some(scaleToSize);
-            return this;
+            _pixelFormat = pixelFormat;
         }
 
-        public FFmpegComplexFilterBuilder WithBlackBars(IDisplaySize padToSize)
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithWatermark(
+        Option<ChannelWatermark> watermark,
+        Option<List<FadePoint>> maybeFadePoints,
+        IDisplaySize resolution,
+        Option<int> watermarkIndex)
+    {
+        _watermark = watermark;
+        _maybeFadePoints = maybeFadePoints;
+        _resolution = resolution;
+        _watermarkIndex = watermarkIndex;
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithBoxBlur(bool boxBlur)
+    {
+        _boxBlur = boxBlur;
+        return this;
+    }
+
+    public FFmpegComplexFilterBuilder WithSubtitleFile(Option<string> subtitleFile)
+    {
+        foreach (string file in subtitleFile)
         {
-            _padToSize = Some(padToSize);
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithDeinterlace(bool deinterlace)
-        {
-            _deinterlace = deinterlace;
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithAlignedAudio(Option<TimeSpan> audioDuration)
-        {
-            _audioDuration = audioDuration;
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithNormalizeLoudness(bool normalizeLoudness)
-        {
-            _normalizeLoudness = normalizeLoudness;
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithInputCodec(Option<string> maybeCodec)
-        {
-            foreach (string codec in maybeCodec)
-            {
-                _inputCodec = codec;
-            }
-
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithDecoder(string decoder)
-        {
-            _videoDecoder = decoder;
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithInputPixelFormat(Option<string> maybePixelFormat)
-        {
-            foreach (string pixelFormat in maybePixelFormat)
-            {
-                _pixelFormat = pixelFormat;
-            }
-
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithWatermark(
-            Option<ChannelWatermark> watermark,
-            Option<List<FadePoint>> maybeFadePoints,
-            IDisplaySize resolution,
-            Option<int> watermarkIndex)
-        {
-            _watermark = watermark;
-            _maybeFadePoints = maybeFadePoints;
-            _resolution = resolution;
-            _watermarkIndex = watermarkIndex;
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithBoxBlur(bool boxBlur)
-        {
-            _boxBlur = boxBlur;
-            return this;
-        }
-
-        public FFmpegComplexFilterBuilder WithSubtitleFile(Option<string> subtitleFile)
-        {
-            foreach (string file in subtitleFile)
-            {
-                string effectiveFile = file;
-                string fontsDir = FileSystemLayout.ResourcesCacheFolder;
+            string effectiveFile = file;
+            string fontsDir = FileSystemLayout.ResourcesCacheFolder;
                 
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                {
-                    fontsDir = fontsDir
-                        .Replace(@"\", @"/\")
-                        .Replace(@":/", @"\\:/");
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                fontsDir = fontsDir
+                    .Replace(@"\", @"/\")
+                    .Replace(@":/", @"\\:/");
                     
-                    effectiveFile = effectiveFile
-                        .Replace(@"\", @"/\")
-                        .Replace(@":/", @"\\:/");
-                }
-
-                _subtitle = $"subtitles={effectiveFile}:fontsdir={fontsDir}";
+                effectiveFile = effectiveFile
+                    .Replace(@"\", @"/\")
+                    .Replace(@":/", @"\\:/");
             }
 
-            return this;
+            _subtitle = $"subtitles={effectiveFile}:fontsdir={fontsDir}";
         }
 
-        public FFmpegComplexFilterBuilder WithVideoEncoder(string videoEncoder)
-        {
-            _videoEncoder = videoEncoder;
-            return this;
-        }
+        return this;
+    }
 
-        public Option<FFmpegComplexFilter> Build(bool videoOnly, int videoInput, int videoStreamIndex, int audioInput, Option<int> audioStreamIndex, bool isSong)
-        {
-            // since .Contains is used on pixel format, we need it to be not null
-            _pixelFormat ??= string.Empty;
+    public FFmpegComplexFilterBuilder WithVideoEncoder(string videoEncoder)
+    {
+        _videoEncoder = videoEncoder;
+        return this;
+    }
+
+    public Option<FFmpegComplexFilter> Build(bool videoOnly, int videoInput, int videoStreamIndex, int audioInput, Option<int> audioStreamIndex, bool isSong)
+    {
+        // since .Contains is used on pixel format, we need it to be not null
+        _pixelFormat ??= string.Empty;
             
-            var complexFilter = new StringBuilder();
+        var complexFilter = new StringBuilder();
 
-            string videoLabel = $"{videoInput}:{(isSong ? "v" : videoStreamIndex.ToString())}";
-            string audioLabel = audioStreamIndex.Match(index => $"{audioInput}:{index}", () => "0:a");
+        string videoLabel = $"{videoInput}:{(isSong ? "v" : videoStreamIndex.ToString())}";
+        string audioLabel = audioStreamIndex.Match(index => $"{audioInput}:{index}", () => "0:a");
 
-            HardwareAccelerationKind acceleration = _hardwareAccelerationKind.IfNone(HardwareAccelerationKind.None);
+        HardwareAccelerationKind acceleration = _hardwareAccelerationKind.IfNone(HardwareAccelerationKind.None);
 
-            bool isHardwareDecode = acceleration switch
+        bool isHardwareDecode = acceleration switch
+        {
+            HardwareAccelerationKind.Vaapi => !isSong && _inputCodec != "mpeg4" &&
+                                              (_deinterlace == false || !_pixelFormat.Contains("p10le")),
+
+            // we need an initial hwupload_cuda when only padding with these pixel formats
+            HardwareAccelerationKind.Nvenc when _scaleToSize.IsNone && _padToSize.IsSome =>
+                !isSong && !_pixelFormat.Contains("p10le") && !_pixelFormat.Contains("444"),
+
+            HardwareAccelerationKind.Nvenc => !isSong &&
+                                              (string.IsNullOrWhiteSpace(_videoDecoder) ||
+                                               _videoDecoder.Contains("cuvid")),
+            HardwareAccelerationKind.Qsv => !isSong,
+            HardwareAccelerationKind.VideoToolbox => false,
+            _ => false
+        };
+
+        bool nvencDeinterlace = acceleration == HardwareAccelerationKind.Nvenc && _videoDecoder == "mpeg2_cuvid" &&
+                                _deinterlace; 
+        // mpeg2_cuvid will handle deinterlace and is "not" a hardware decode
+        if (nvencDeinterlace)
+        {
+            _deinterlace = false;
+            isHardwareDecode = false;
+        }
+
+        var audioFilterQueue = new List<string>();
+        var videoFilterQueue = new List<string>();
+        var watermarkPreprocess = new List<string>();
+        string watermarkOverlay = string.Empty;
+            
+        if (_normalizeLoudness)
+        {
+            audioFilterQueue.Add("loudnorm=I=-16:TP=-1.5:LRA=11");
+        }
+
+        _audioDuration.IfSome(
+            audioDuration =>
             {
-                HardwareAccelerationKind.Vaapi => !isSong && _inputCodec != "mpeg4" &&
-                                                  (_deinterlace == false || !_pixelFormat.Contains("p10le")),
+                var durationString = audioDuration.TotalMilliseconds.ToString(NumberFormatInfo.InvariantInfo);
+                audioFilterQueue.Add($"apad=whole_dur={durationString}ms");
+            });
 
-                // we need an initial hwupload_cuda when only padding with these pixel formats
-                HardwareAccelerationKind.Nvenc when _scaleToSize.IsNone && _padToSize.IsSome =>
-                    !isSong && !_pixelFormat.Contains("p10le") && !_pixelFormat.Contains("444"),
+        bool usesHardwareFilters = acceleration != HardwareAccelerationKind.None &&
+                                   acceleration != HardwareAccelerationKind.VideoToolbox &&
+                                   !isHardwareDecode &&
+                                   (_deinterlace || _scaleToSize.IsSome);
 
-                HardwareAccelerationKind.Nvenc => !isSong &&
-                                                  (string.IsNullOrWhiteSpace(_videoDecoder) ||
-                                                   _videoDecoder.Contains("cuvid")),
-                HardwareAccelerationKind.Qsv => !isSong,
-                HardwareAccelerationKind.VideoToolbox => false,
-                _ => false
+        if (isSong)
+        {
+            switch (acceleration)
+            {
+                case HardwareAccelerationKind.Qsv:
+                    videoFilterQueue.Add("format=nv12");
+                    break;
+                case HardwareAccelerationKind.Vaapi:
+                    videoFilterQueue.Add("format=nv12|vaapi");
+                    break;
+                default:
+                    videoFilterQueue.Add("format=yuv420p");
+                    break;
+            }
+        }
+
+        switch (usesHardwareFilters || isSong, acceleration)
+        {
+            case (true, HardwareAccelerationKind.Nvenc):
+                videoFilterQueue.Add("hwupload_cuda");
+                break;
+            case (true, HardwareAccelerationKind.Qsv):
+                videoFilterQueue.Add("hwupload=extra_hw_frames=64");
+                break;
+            case (true, HardwareAccelerationKind.Vaapi):
+                videoFilterQueue.Add("hwupload");
+                break;
+            case (true, _) when usesHardwareFilters:
+                videoFilterQueue.Add("hwupload");
+                break;
+        }
+
+        if (_deinterlace)
+        {
+            Option<string> maybeFilter = acceleration switch
+            {
+                HardwareAccelerationKind.Qsv => "deinterlace_qsv",
+                HardwareAccelerationKind.Nvenc when !usesHardwareFilters && _pixelFormat.Contains("p10le") =>
+                    "hwupload_cuda,yadif_cuda",
+                HardwareAccelerationKind.Nvenc => "yadif_cuda",
+                HardwareAccelerationKind.Vaapi => "deinterlace_vaapi",
+                _ => "yadif=1"
             };
 
-            bool nvencDeinterlace = acceleration == HardwareAccelerationKind.Nvenc && _videoDecoder == "mpeg2_cuvid" &&
-                                    _deinterlace; 
-            // mpeg2_cuvid will handle deinterlace and is "not" a hardware decode
-            if (nvencDeinterlace)
+            foreach (string filter in maybeFilter)
             {
-                _deinterlace = false;
-                isHardwareDecode = false;
+                videoFilterQueue.Add(filter);
             }
+        }
 
-            var audioFilterQueue = new List<string>();
-            var videoFilterQueue = new List<string>();
-            var watermarkPreprocess = new List<string>();
-            string watermarkOverlay = string.Empty;
-            
-            if (_normalizeLoudness)
+        string[] h264hevc = { "h264", "hevc" };
+
+        if (_deinterlace == false && acceleration == HardwareAccelerationKind.Vaapi &&
+            (_pixelFormat ?? string.Empty).EndsWith("p10le") &&
+            h264hevc.Contains(_inputCodec) && (_pixelFormat != "yuv420p10le" || _inputCodec != "hevc"))
+        {
+            videoFilterQueue.Add("format=p010le,format=nv12|vaapi,hwupload");
+        }
+
+        if (acceleration == HardwareAccelerationKind.Vaapi && _pixelFormat == "yuv444p" && h264hevc.Contains(_inputCodec))
+        {
+            videoFilterQueue.Add("format=nv12|vaapi,hwupload");
+        }
+
+        bool scaleOrPad = _scaleToSize.IsSome || _padToSize.IsSome;
+        bool usesSoftwareFilters = _padToSize.IsSome || _watermark.IsSome;
+        bool hasFadePoints = _maybeFadePoints.Map(fp => fp.Count).IfNone(0) > 0;
+
+        var softwareFilterQueue = new List<string>();
+        if (usesSoftwareFilters)
+        {
+            if (acceleration != HardwareAccelerationKind.None && (isHardwareDecode || usesHardwareFilters))
             {
-                audioFilterQueue.Add("loudnorm=I=-16:TP=-1.5:LRA=11");
-            }
-
-            _audioDuration.IfSome(
-                audioDuration =>
+                Option<string> maybeFormat = acceleration switch
                 {
-                    var durationString = audioDuration.TotalMilliseconds.ToString(NumberFormatInfo.InvariantInfo);
-                    audioFilterQueue.Add($"apad=whole_dur={durationString}ms");
-                });
-
-            bool usesHardwareFilters = acceleration != HardwareAccelerationKind.None &&
-                                       acceleration != HardwareAccelerationKind.VideoToolbox &&
-                                       !isHardwareDecode &&
-                                       (_deinterlace || _scaleToSize.IsSome);
-
-            if (isSong)
-            {
-                switch (acceleration)
-                {
-                    case HardwareAccelerationKind.Qsv:
-                        videoFilterQueue.Add("format=nv12");
-                        break;
-                    case HardwareAccelerationKind.Vaapi:
-                        videoFilterQueue.Add("format=nv12|vaapi");
-                        break;
-                    default:
-                        videoFilterQueue.Add("format=yuv420p");
-                        break;
-                }
-            }
-
-            switch (usesHardwareFilters || isSong, acceleration)
-            {
-                case (true, HardwareAccelerationKind.Nvenc):
-                    videoFilterQueue.Add("hwupload_cuda");
-                    break;
-                case (true, HardwareAccelerationKind.Qsv):
-                    videoFilterQueue.Add("hwupload=extra_hw_frames=64");
-                    break;
-                case (true, HardwareAccelerationKind.Vaapi):
-                    videoFilterQueue.Add("hwupload");
-                    break;
-                case (true, _) when usesHardwareFilters:
-                    videoFilterQueue.Add("hwupload");
-                    break;
-            }
-
-            if (_deinterlace)
-            {
-                Option<string> maybeFilter = acceleration switch
-                {
-                    HardwareAccelerationKind.Qsv => "deinterlace_qsv",
-                    HardwareAccelerationKind.Nvenc when !usesHardwareFilters && _pixelFormat.Contains("p10le") =>
-                        "hwupload_cuda,yadif_cuda",
-                    HardwareAccelerationKind.Nvenc => "yadif_cuda",
-                    HardwareAccelerationKind.Vaapi => "deinterlace_vaapi",
-                    _ => "yadif=1"
+                    HardwareAccelerationKind.Vaapi => "format=nv12|vaapi",
+                    HardwareAccelerationKind.Nvenc when _padToSize.IsNone || nvencDeinterlace => None,
+                    HardwareAccelerationKind.Nvenc when _pixelFormat == "yuv420p10le" =>
+                        "format=p010le,format=nv12",
+                    HardwareAccelerationKind.Qsv when isSong => "format=nv12,format=yuv420p",
+                    _ when isSong => "format=yuv420p",
+                    _ => "format=nv12"
                 };
 
-                foreach (string filter in maybeFilter)
+                foreach (string format in maybeFormat)
                 {
-                    videoFilterQueue.Add(filter);
+                    softwareFilterQueue.Add("hwdownload");
+                    softwareFilterQueue.Add(format);
+                }
+
+                if (nvencDeinterlace)
+                {
+                    softwareFilterQueue.Add("hwdownload");
                 }
             }
 
-            string[] h264hevc = { "h264", "hevc" };
-
-            if (_deinterlace == false && acceleration == HardwareAccelerationKind.Vaapi &&
-                (_pixelFormat ?? string.Empty).EndsWith("p10le") &&
-                h264hevc.Contains(_inputCodec) && (_pixelFormat != "yuv420p10le" || _inputCodec != "hevc"))
+            if (_boxBlur)
             {
-                videoFilterQueue.Add("format=p010le,format=nv12|vaapi,hwupload");
+                softwareFilterQueue.Add("boxblur=40");
             }
 
-            if (acceleration == HardwareAccelerationKind.Vaapi && _pixelFormat == "yuv444p" && h264hevc.Contains(_inputCodec))
+            if (videoOnly)
             {
-                videoFilterQueue.Add("format=nv12|vaapi,hwupload");
+                softwareFilterQueue.Add("deband");
             }
 
-            bool scaleOrPad = _scaleToSize.IsSome || _padToSize.IsSome;
-            bool usesSoftwareFilters = _padToSize.IsSome || _watermark.IsSome;
-            bool hasFadePoints = _maybeFadePoints.Map(fp => fp.Count).IfNone(0) > 0;
-
-            var softwareFilterQueue = new List<string>();
-            if (usesSoftwareFilters)
+            foreach (ChannelWatermark watermark in _watermark)
             {
-                if (acceleration != HardwareAccelerationKind.None && (isHardwareDecode || usesHardwareFilters))
+                Option<string> maybeFormats = acceleration switch
                 {
-                    Option<string> maybeFormat = acceleration switch
+                    // overlay_cuda only supports alpha with yuva420p 
+                    HardwareAccelerationKind.Nvenc => "yuva420p",
+
+                    _ when watermark.Opacity != 100 || hasFadePoints =>
+                        "yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8",
+
+                    _ => None
+                };
+
+                foreach (string formats in maybeFormats)
+                {
+                    watermarkPreprocess.Add($"format={formats}");
+                }
+
+                double horizontalMargin = Math.Round(watermark.HorizontalMarginPercent / 100.0 * _resolution.Width);
+                double verticalMargin = Math.Round(watermark.VerticalMarginPercent / 100.0 * _resolution.Height);
+
+                string position = watermark.Location switch
+                {
+                    WatermarkLocation.BottomLeft => $"x={horizontalMargin}:y=H-h-{verticalMargin}",
+                    WatermarkLocation.TopLeft => $"x={horizontalMargin}:y={verticalMargin}",
+                    WatermarkLocation.TopRight => $"x=W-w-{horizontalMargin}:y={verticalMargin}",
+                    WatermarkLocation.TopMiddle => $"x=(W-w)/2:y={verticalMargin}",
+                    WatermarkLocation.RightMiddle => $"x=W-w-{horizontalMargin}:y=(H-h)/2",
+                    WatermarkLocation.BottomMiddle => $"x=(W-w)/2:y=H-h-{verticalMargin}",
+                    WatermarkLocation.LeftMiddle => $"x={horizontalMargin}:y=(H-h)/2",
+                    _ => $"x=W-w-{horizontalMargin}:y=H-h-{verticalMargin}"
+                };
+
+                if (watermark.Opacity != 100)
+                {
+                    double opacity = watermark.Opacity / 100.0;
+                    watermarkPreprocess.Add($"colorchannelmixer=aa={opacity:F2}");
+                }
+
+                if (watermark.Size == WatermarkSize.Scaled)
+                {
+                    double width = Math.Round(watermark.WidthPercent / 100.0 * _resolution.Width);
+                    watermarkPreprocess.Add($"scale={width}:-1");
+                }
+
+                foreach (List<FadePoint> fadePoints in _maybeFadePoints)
+                {
+                    watermarkPreprocess.AddRange(fadePoints.Map(fp => fp.ToFilter()));
+                }
+
+                if (acceleration == HardwareAccelerationKind.Nvenc)
+                {
+                    watermarkPreprocess.Add("hwupload_cuda");
+                }
+
+                watermarkOverlay = acceleration switch
+                {
+                    HardwareAccelerationKind.Nvenc => $"overlay_cuda={position}",
+                    _ => $"overlay={position}"
+                };
+
+                if (hasFadePoints && acceleration != HardwareAccelerationKind.Nvenc)
+                {
+                    watermarkOverlay += "," + acceleration switch
                     {
                         HardwareAccelerationKind.Vaapi => "format=nv12|vaapi",
-                        HardwareAccelerationKind.Nvenc when _padToSize.IsNone || nvencDeinterlace => None,
-                        HardwareAccelerationKind.Nvenc when _pixelFormat == "yuv420p10le" =>
-                            "format=p010le,format=nv12",
-                        HardwareAccelerationKind.Qsv when isSong => "format=nv12,format=yuv420p",
                         _ when isSong => "format=yuv420p",
                         _ => "format=nv12"
                     };
-
-                    foreach (string format in maybeFormat)
-                    {
-                        softwareFilterQueue.Add("hwdownload");
-                        softwareFilterQueue.Add(format);
-                    }
-
-                    if (nvencDeinterlace)
-                    {
-                        softwareFilterQueue.Add("hwdownload");
-                    }
-                }
-
-                if (_boxBlur)
-                {
-                    softwareFilterQueue.Add("boxblur=40");
-                }
-
-                if (videoOnly)
-                {
-                    softwareFilterQueue.Add("deband");
-                }
-
-                foreach (ChannelWatermark watermark in _watermark)
-                {
-                    Option<string> maybeFormats = acceleration switch
-                    {
-                        // overlay_cuda only supports alpha with yuva420p 
-                        HardwareAccelerationKind.Nvenc => "yuva420p",
-
-                        _ when watermark.Opacity != 100 || hasFadePoints =>
-                            "yuva420p|yuva444p|yuva422p|rgba|abgr|bgra|gbrap|ya8",
-
-                        _ => None
-                    };
-
-                    foreach (string formats in maybeFormats)
-                    {
-                        watermarkPreprocess.Add($"format={formats}");
-                    }
-
-                    double horizontalMargin = Math.Round(watermark.HorizontalMarginPercent / 100.0 * _resolution.Width);
-                    double verticalMargin = Math.Round(watermark.VerticalMarginPercent / 100.0 * _resolution.Height);
-
-                    string position = watermark.Location switch
-                    {
-                        WatermarkLocation.BottomLeft => $"x={horizontalMargin}:y=H-h-{verticalMargin}",
-                        WatermarkLocation.TopLeft => $"x={horizontalMargin}:y={verticalMargin}",
-                        WatermarkLocation.TopRight => $"x=W-w-{horizontalMargin}:y={verticalMargin}",
-                        WatermarkLocation.TopMiddle => $"x=(W-w)/2:y={verticalMargin}",
-                        WatermarkLocation.RightMiddle => $"x=W-w-{horizontalMargin}:y=(H-h)/2",
-                        WatermarkLocation.BottomMiddle => $"x=(W-w)/2:y=H-h-{verticalMargin}",
-                        WatermarkLocation.LeftMiddle => $"x={horizontalMargin}:y=(H-h)/2",
-                        _ => $"x=W-w-{horizontalMargin}:y=H-h-{verticalMargin}"
-                    };
-
-                    if (watermark.Opacity != 100)
-                    {
-                        double opacity = watermark.Opacity / 100.0;
-                        watermarkPreprocess.Add($"colorchannelmixer=aa={opacity:F2}");
-                    }
-
-                    if (watermark.Size == WatermarkSize.Scaled)
-                    {
-                        double width = Math.Round(watermark.WidthPercent / 100.0 * _resolution.Width);
-                        watermarkPreprocess.Add($"scale={width}:-1");
-                    }
-
-                    foreach (List<FadePoint> fadePoints in _maybeFadePoints)
-                    {
-                        watermarkPreprocess.AddRange(fadePoints.Map(fp => fp.ToFilter()));
-                    }
-
-                    if (acceleration == HardwareAccelerationKind.Nvenc)
-                    {
-                        watermarkPreprocess.Add("hwupload_cuda");
-                    }
-
-                    watermarkOverlay = acceleration switch
-                    {
-                        HardwareAccelerationKind.Nvenc => $"overlay_cuda={position}",
-                        _ => $"overlay={position}"
-                    };
-
-                    if (hasFadePoints && acceleration != HardwareAccelerationKind.Nvenc)
-                    {
-                        watermarkOverlay += "," + acceleration switch
-                        {
-                            HardwareAccelerationKind.Vaapi => "format=nv12|vaapi",
-                            _ when isSong => "format=yuv420p",
-                            _ => "format=nv12"
-                        };
-                    }
                 }
             }
+        }
             
-            string outputPixelFormat = null;
-            if (!usesSoftwareFilters && string.IsNullOrWhiteSpace(watermarkOverlay))
+        string outputPixelFormat = null;
+        if (!usesSoftwareFilters && string.IsNullOrWhiteSpace(watermarkOverlay))
+        {
+            switch (acceleration, _videoEncoder, _pixelFormat)
             {
-                switch (acceleration, _videoEncoder, _pixelFormat)
-                {
-                    case (HardwareAccelerationKind.Nvenc, "h264_nvenc", "yuv420p10le"):
-                        outputPixelFormat = "yuv420p";
-                        break;
-                    case (HardwareAccelerationKind.Nvenc, "h264_nvenc", "yuv444p10le"):
-                        outputPixelFormat = "yuv444p";
-                        break;
-                }
+                case (HardwareAccelerationKind.Nvenc, "h264_nvenc", "yuv420p10le"):
+                    outputPixelFormat = "yuv420p";
+                    break;
+                case (HardwareAccelerationKind.Nvenc, "h264_nvenc", "yuv444p10le"):
+                    outputPixelFormat = "yuv444p";
+                    break;
             }
+        }
 
-            string outputFormat = (_videoEncoder, _pixelFormat) switch
+        string outputFormat = (_videoEncoder, _pixelFormat) switch
+        {
+            ("hevc_nvenc", "yuv420p10le") => "p010le",
+            ("h264_nvenc", "yuv420p10le") => "p010le",
+            _ => null
+        };
+
+        _scaleToSize.IfSome(
+            size =>
             {
-                ("hevc_nvenc", "yuv420p10le") => "p010le",
-                ("h264_nvenc", "yuv420p10le") => "p010le",
-                _ => null
-            };
-
-            _scaleToSize.IfSome(
-                size =>
+                string filter = acceleration switch
                 {
-                    string filter = acceleration switch
-                    {
-                        HardwareAccelerationKind.Qsv => $"scale_qsv=w={size.Width}:h={size.Height}",
-                        HardwareAccelerationKind.Nvenc when _watermark.IsSome && _scaleToSize.IsNone =>
-                            $"format=yuv420p,hwupload_cuda,scale_cuda={size.Width}:{size.Height}",
-                        HardwareAccelerationKind.Nvenc when _watermark.IsSome && _padToSize.IsNone =>
-                            $"scale_cuda={size.Width}:{size.Height}",
-                        HardwareAccelerationKind.Nvenc when _watermark.IsNone && !string.IsNullOrEmpty(outputFormat) =>
-                            $"scale_cuda={size.Width}:{size.Height}:format={outputFormat}",
-                        HardwareAccelerationKind.Nvenc when _pixelFormat is "yuv420p10le" && usesHardwareFilters == false =>
-                            $"hwupload_cuda,scale_cuda={size.Width}:{size.Height}",
-                        HardwareAccelerationKind.Nvenc => $"scale_cuda={size.Width}:{size.Height}",
-                        HardwareAccelerationKind.Vaapi => $"scale_vaapi=format=nv12:w={size.Width}:h={size.Height}",
-                        _ when videoOnly => $"scale={size.Width}:{size.Height}:force_original_aspect_ratio=increase,crop={size.Width}:{size.Height}",
-                        _ => $"scale={size.Width}:{size.Height}:flags=fast_bilinear"
-                    };
-
-                    if (!string.IsNullOrWhiteSpace(filter))
-                    {
-                        videoFilterQueue.Add(filter);
-                    }
-                });
-
-            if (scaleOrPad && _boxBlur == false)
-            {
-                if (acceleration == HardwareAccelerationKind.Nvenc)
-                {
-                    if (!isHardwareDecode && !string.IsNullOrWhiteSpace(outputPixelFormat))
-                    {
-                        videoFilterQueue.Add($"hwdownload,format={outputPixelFormat}");
-                    }
-                }
-
-                videoFilterQueue.Add("setsar=1");
-            }
-
-            videoFilterQueue.AddRange(softwareFilterQueue);
-
-            _padToSize.IfSome(size => videoFilterQueue.Add($"pad={size.Width}:{size.Height}:(ow-iw)/2:(oh-ih)/2"));
-            
-            if (acceleration == HardwareAccelerationKind.Nvenc && _watermark.IsSome)
-            {
-                if (_scaleToSize.IsSome)
-                {
-                    videoFilterQueue.Add("hwdownload,format=nv12,format=yuv420p");
-                    videoFilterQueue.Add("hwupload_cuda");
-                }
-                else if (_padToSize.IsNone)
-                {
-                    videoFilterQueue.Add("scale_cuda=format=yuv420p");
-                }
-                else
-                {
-                    videoFilterQueue.Add("format=yuv420p");
-                    videoFilterQueue.Add("hwupload_cuda");
-                }
-            }
-
-            foreach (string subtitle in _subtitle)
-            {
-                videoFilterQueue.Add(subtitle);
-            }
-            
-            if (usesSoftwareFilters && acceleration != HardwareAccelerationKind.None &&
-                string.IsNullOrWhiteSpace(watermarkOverlay))
-            {
-                string upload = acceleration switch
-                {
-                    HardwareAccelerationKind.Qsv => "hwupload=extra_hw_frames=64",
-                    _ => "hwupload"
+                    HardwareAccelerationKind.Qsv => $"scale_qsv=w={size.Width}:h={size.Height}",
+                    HardwareAccelerationKind.Nvenc when _watermark.IsSome && _scaleToSize.IsNone =>
+                        $"format=yuv420p,hwupload_cuda,scale_cuda={size.Width}:{size.Height}",
+                    HardwareAccelerationKind.Nvenc when _watermark.IsSome && _padToSize.IsNone =>
+                        $"scale_cuda={size.Width}:{size.Height}",
+                    HardwareAccelerationKind.Nvenc when _watermark.IsNone && !string.IsNullOrEmpty(outputFormat) =>
+                        $"scale_cuda={size.Width}:{size.Height}:format={outputFormat}",
+                    HardwareAccelerationKind.Nvenc when _pixelFormat is "yuv420p10le" && usesHardwareFilters == false =>
+                        $"hwupload_cuda,scale_cuda={size.Width}:{size.Height}",
+                    HardwareAccelerationKind.Nvenc => $"scale_cuda={size.Width}:{size.Height}",
+                    HardwareAccelerationKind.Vaapi => $"scale_vaapi=format=nv12:w={size.Width}:h={size.Height}",
+                    _ when videoOnly => $"scale={size.Width}:{size.Height}:force_original_aspect_ratio=increase,crop={size.Width}:{size.Height}",
+                    _ => $"scale={size.Width}:{size.Height}:flags=fast_bilinear"
                 };
-                videoFilterQueue.Add(upload);
+
+                if (!string.IsNullOrWhiteSpace(filter))
+                {
+                    videoFilterQueue.Add(filter);
+                }
+            });
+
+        if (scaleOrPad && _boxBlur == false)
+        {
+            if (acceleration == HardwareAccelerationKind.Nvenc)
+            {
+                if (!isHardwareDecode && !string.IsNullOrWhiteSpace(outputPixelFormat))
+                {
+                    videoFilterQueue.Add($"hwdownload,format={outputPixelFormat}");
+                }
             }
 
-            bool hasAudioFilters = audioFilterQueue.Any();
+            videoFilterQueue.Add("setsar=1");
+        }
+
+        videoFilterQueue.AddRange(softwareFilterQueue);
+
+        _padToSize.IfSome(size => videoFilterQueue.Add($"pad={size.Width}:{size.Height}:(ow-iw)/2:(oh-ih)/2"));
+            
+        if (acceleration == HardwareAccelerationKind.Nvenc && _watermark.IsSome)
+        {
+            if (_scaleToSize.IsSome)
+            {
+                videoFilterQueue.Add("hwdownload,format=nv12,format=yuv420p");
+                videoFilterQueue.Add("hwupload_cuda");
+            }
+            else if (_padToSize.IsNone)
+            {
+                videoFilterQueue.Add("scale_cuda=format=yuv420p");
+            }
+            else
+            {
+                videoFilterQueue.Add("format=yuv420p");
+                videoFilterQueue.Add("hwupload_cuda");
+            }
+        }
+
+        foreach (string subtitle in _subtitle)
+        {
+            videoFilterQueue.Add(subtitle);
+        }
+            
+        if (usesSoftwareFilters && acceleration != HardwareAccelerationKind.None &&
+            string.IsNullOrWhiteSpace(watermarkOverlay))
+        {
+            string upload = acceleration switch
+            {
+                HardwareAccelerationKind.Qsv => "hwupload=extra_hw_frames=64",
+                _ => "hwupload"
+            };
+            videoFilterQueue.Add(upload);
+        }
+
+        bool hasAudioFilters = audioFilterQueue.Any();
+        if (hasAudioFilters)
+        {
+            complexFilter.Append($"[{audioLabel}]");
+            complexFilter.Append(string.Join(",", audioFilterQueue));
+            audioLabel = "[a]";
+            complexFilter.Append(audioLabel);
+        }
+
+        // vaapi downsample 10bit hevc to 8bit h264
+        if (acceleration == HardwareAccelerationKind.Vaapi && !videoFilterQueue.Any() &&
+            _pixelFormat == "yuv420p10le" && _videoEncoder.StartsWith("h264"))
+        {
+            videoFilterQueue.Add("scale_vaapi=format=nv12");
+        }
+
+        if (videoFilterQueue.Any() || !string.IsNullOrWhiteSpace(watermarkOverlay))
+        {
             if (hasAudioFilters)
             {
-                complexFilter.Append($"[{audioLabel}]");
-                complexFilter.Append(string.Join(",", audioFilterQueue));
-                audioLabel = "[a]";
-                complexFilter.Append(audioLabel);
+                complexFilter.Append(';');
             }
 
-            // vaapi downsample 10bit hevc to 8bit h264
-            if (acceleration == HardwareAccelerationKind.Vaapi && !videoFilterQueue.Any() &&
-                _pixelFormat == "yuv420p10le" && _videoEncoder.StartsWith("h264"))
+            if (videoFilterQueue.Any())
             {
-                videoFilterQueue.Add("scale_vaapi=format=nv12");
+                complexFilter.Append($"[{videoLabel}]");
+                var filters = string.Join(",", videoFilterQueue);
+                complexFilter.Append(filters);
             }
 
-            if (videoFilterQueue.Any() || !string.IsNullOrWhiteSpace(watermarkOverlay))
+            if (!string.IsNullOrWhiteSpace(watermarkOverlay))
             {
-                if (hasAudioFilters)
-                {
-                    complexFilter.Append(';');
-                }
-
                 if (videoFilterQueue.Any())
                 {
-                    complexFilter.Append($"[{videoLabel}]");
-                    var filters = string.Join(",", videoFilterQueue);
-                    complexFilter.Append(filters);
+                    complexFilter.Append("[vt];");
                 }
 
-                if (!string.IsNullOrWhiteSpace(watermarkOverlay))
+                var watermarkLabel = $"[{audioInput+1}:v]";
+                foreach (int index in _watermarkIndex)
                 {
-                    if (videoFilterQueue.Any())
-                    {
-                        complexFilter.Append("[vt];");
-                    }
+                    watermarkLabel = $"[{audioInput+1}:{index}]";
+                }
 
-                    var watermarkLabel = $"[{audioInput+1}:v]";
-                    foreach (int index in _watermarkIndex)
-                    {
-                        watermarkLabel = $"[{audioInput+1}:{index}]";
-                    }
+                if (watermarkPreprocess.Count > 0)
+                {
+                    var joined = string.Join(",", watermarkPreprocess);
+                    complexFilter.Append($"{watermarkLabel}{joined}[wmp];");
+                    watermarkLabel = "[wmp]";
+                }
 
-                    if (watermarkPreprocess.Count > 0)
-                    {
-                        var joined = string.Join(",", watermarkPreprocess);
-                        complexFilter.Append($"{watermarkLabel}{joined}[wmp];");
-                        watermarkLabel = "[wmp]";
-                    }
+                complexFilter.Append(
+                    videoFilterQueue.Any()
+                        ? $"[vt]{watermarkLabel}{watermarkOverlay}"
+                        : $"[{videoLabel}]{watermarkLabel}{watermarkOverlay}");
 
-                    complexFilter.Append(
-                        videoFilterQueue.Any()
-                            ? $"[vt]{watermarkLabel}{watermarkOverlay}"
-                            : $"[{videoLabel}]{watermarkLabel}{watermarkOverlay}");
-
-                    if (usesSoftwareFilters && acceleration != HardwareAccelerationKind.None)
+                if (usesSoftwareFilters && acceleration != HardwareAccelerationKind.None)
+                {
+                    switch (isSong, acceleration)
                     {
-                        switch (isSong, acceleration)
-                        {
-                            case (true, HardwareAccelerationKind.Nvenc):
-                                complexFilter.Append(",hwupload_cuda");
-                                break;
-                            // no need to upload since we're already in the GPU with overlay_cuda
-                            case (_, HardwareAccelerationKind.Nvenc) when scaleOrPad == false && _watermark.IsSome:
-                                break;
-                            case (_, HardwareAccelerationKind.Qsv):
-                                complexFilter.Append(",format=yuv420p,hwupload=extra_hw_frames=64");
-                                break;
-                            default:
-                                complexFilter.Append(",hwupload");
-                                break;
-                        }
+                        case (true, HardwareAccelerationKind.Nvenc):
+                            complexFilter.Append(",hwupload_cuda");
+                            break;
+                        // no need to upload since we're already in the GPU with overlay_cuda
+                        case (_, HardwareAccelerationKind.Nvenc) when scaleOrPad == false && _watermark.IsSome:
+                            break;
+                        case (_, HardwareAccelerationKind.Qsv):
+                            complexFilter.Append(",format=yuv420p,hwupload=extra_hw_frames=64");
+                            break;
+                        default:
+                            complexFilter.Append(",hwupload");
+                            break;
                     }
                 }
-                
-                videoLabel = "[v]";
-                complexFilter.Append(videoLabel);
             }
-
-            var filterResult = complexFilter.ToString();
-            return string.IsNullOrWhiteSpace(filterResult)
-                ? Option<FFmpegComplexFilter>.None
-                : new FFmpegComplexFilter(filterResult, videoLabel, audioLabel, outputPixelFormat);
+                
+            videoLabel = "[v]";
+            complexFilter.Append(videoLabel);
         }
+
+        var filterResult = complexFilter.ToString();
+        return string.IsNullOrWhiteSpace(filterResult)
+            ? Option<FFmpegComplexFilter>.None
+            : new FFmpegComplexFilter(filterResult, videoLabel, audioLabel, outputPixelFormat);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegLibraryProcessService.cs b/ErsatzTV.Core/FFmpeg/FFmpegLibraryProcessService.cs
index a7616ca05..d3579601a 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegLibraryProcessService.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegLibraryProcessService.cs
@@ -1,10 +1,5 @@
-using System;
-using System.Diagnostics;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
+using System.Diagnostics;
 using System.Text;
-using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.FFmpeg;
@@ -13,10 +8,7 @@ using ErsatzTV.FFmpeg.Environment;
 using ErsatzTV.FFmpeg.Format;
 using ErsatzTV.FFmpeg.OutputFormat;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using FFmpegState = ErsatzTV.FFmpeg.FFmpegState;
 using MediaStream = ErsatzTV.Core.Domain.MediaStream;
 
 namespace ErsatzTV.Core.FFmpeg;
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegLocator.cs b/ErsatzTV.Core/FFmpeg/FFmpegLocator.cs
index b630e8405..917327faa 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegLocator.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegLocator.cs
@@ -1,85 +1,80 @@
 using System.Diagnostics;
-using System.IO;
 using System.Runtime.InteropServices;
-using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class FFmpegLocator : IFFmpegLocator
 {
-    public class FFmpegLocator : IFFmpegLocator
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public FFmpegLocator(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<Option<string>> ValidatePath(string executableBase, ConfigElementKey key)
     {
-        private readonly IConfigElementRepository _configElementRepository;
+        Option<ConfigElement> setting = await _configElementRepository.Get(key);
 
-        public FFmpegLocator(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
-
-        public async Task<Option<string>> ValidatePath(string executableBase, ConfigElementKey key)
-        {
-            Option<ConfigElement> setting = await _configElementRepository.Get(key);
-
-            return await setting.MatchAsync(
-                async ce =>
-                {
-                    if (File.Exists(ce.Value))
-                    {
-                        return ce.Value;
-                    }
-
-                    // configured path was incorrect
-                    await _configElementRepository.Delete(ce);
-
-                    return await LocateExecutableAsync(executableBase, key);
-                },
-                async () => await LocateExecutableAsync(executableBase, key));
-        }
-
-        private async Task<Option<string>> LocateExecutableAsync(string executableBase, ConfigElementKey key)
-        {
-            Option<string> maybePath = await LocateExecutableOnPathAsync(executableBase);
-            return await maybePath.MatchAsync(
-                async path =>
-                {
-                    await _configElementRepository.Upsert(key, path);
-                    return Some(path);
-                },
-                () => None);
-        }
-
-        private async Task<Option<string>> LocateExecutableOnPathAsync(string executableBase)
-        {
-            string executable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-                ? $"{executableBase}.exe"
-                : executableBase;
-
-            string processFileName = Process.GetCurrentProcess().MainModule?.FileName ?? string.Empty;
-            if (!string.IsNullOrWhiteSpace(processFileName))
+        return await setting.MatchAsync(
+            async ce =>
             {
-                string localFileName = Path.Combine(Path.GetDirectoryName(processFileName) ?? string.Empty, executable);
-                if (File.Exists(localFileName))
+                if (File.Exists(ce.Value))
                 {
-                    return localFileName;
+                    return ce.Value;
                 }
-            }
 
-            string locateCommand = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "where" : "which";
-            using var p = new Process
-            {
-                StartInfo = new ProcessStartInfo
-                {
-                    UseShellExecute = false,
-                    FileName = locateCommand,
-                    Arguments = executable,
-                    RedirectStandardOutput = true
-                }
-            };
-            p.Start();
-            string path = (await p.StandardOutput.ReadToEndAsync()).Trim();
-            await p.WaitForExitAsync();
-            return p.ExitCode == 0 ? Some(path) : None;
-        }
+                // configured path was incorrect
+                await _configElementRepository.Delete(ce);
+
+                return await LocateExecutableAsync(executableBase, key);
+            },
+            async () => await LocateExecutableAsync(executableBase, key));
     }
-}
+
+    private async Task<Option<string>> LocateExecutableAsync(string executableBase, ConfigElementKey key)
+    {
+        Option<string> maybePath = await LocateExecutableOnPathAsync(executableBase);
+        return await maybePath.MatchAsync(
+            async path =>
+            {
+                await _configElementRepository.Upsert(key, path);
+                return Some(path);
+            },
+            () => None);
+    }
+
+    private async Task<Option<string>> LocateExecutableOnPathAsync(string executableBase)
+    {
+        string executable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+            ? $"{executableBase}.exe"
+            : executableBase;
+
+        string processFileName = Process.GetCurrentProcess().MainModule?.FileName ?? string.Empty;
+        if (!string.IsNullOrWhiteSpace(processFileName))
+        {
+            string localFileName = Path.Combine(Path.GetDirectoryName(processFileName) ?? string.Empty, executable);
+            if (File.Exists(localFileName))
+            {
+                return localFileName;
+            }
+        }
+
+        string locateCommand = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "where" : "which";
+        using var p = new Process
+        {
+            StartInfo = new ProcessStartInfo
+            {
+                UseShellExecute = false,
+                FileName = locateCommand,
+                Arguments = executable,
+                RedirectStandardOutput = true
+            }
+        };
+        p.Start();
+        string path = (await p.StandardOutput.ReadToEndAsync()).Trim();
+        await p.WaitForExitAsync();
+        return p.ExitCode == 0 ? Some(path) : None;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettings.cs b/ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettings.cs
index be3970f20..2db8f0e28 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettings.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettings.cs
@@ -1,33 +1,29 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
-using LanguageExt;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class FFmpegPlaybackSettings
 {
-    public class FFmpegPlaybackSettings
-    {
-        public int ThreadCount { get; set; }
-        public List<string> FormatFlags { get; set; }
-        public HardwareAccelerationKind HardwareAcceleration { get; set; }
-        public string VideoDecoder { get; set; }
-        public bool RealtimeOutput { get; set; }
-        public Option<TimeSpan> StreamSeek { get; set; }
-        public Option<IDisplaySize> ScaledSize { get; set; }
-        public bool PadToDesiredResolution { get; set; }
-        public string VideoCodec { get; set; }
-        public Option<int> VideoBitrate { get; set; }
-        public Option<int> VideoBufferSize { get; set; }
-        public Option<int> AudioBitrate { get; set; }
-        public Option<int> AudioBufferSize { get; set; }
-        public Option<int> AudioChannels { get; set; }
-        public Option<int> AudioSampleRate { get; set; }
-        public Option<TimeSpan> AudioDuration { get; set; }
-        public string AudioCodec { get; set; }
-        public bool Deinterlace { get; set; }
-        public Option<int> VideoTrackTimeScale { get; set; }
-        public bool NormalizeLoudness { get; set; }
-        public Option<int> FrameRate { get; set; }
-    }
-}
+    public int ThreadCount { get; set; }
+    public List<string> FormatFlags { get; set; }
+    public HardwareAccelerationKind HardwareAcceleration { get; set; }
+    public string VideoDecoder { get; set; }
+    public bool RealtimeOutput { get; set; }
+    public Option<TimeSpan> StreamSeek { get; set; }
+    public Option<IDisplaySize> ScaledSize { get; set; }
+    public bool PadToDesiredResolution { get; set; }
+    public string VideoCodec { get; set; }
+    public Option<int> VideoBitrate { get; set; }
+    public Option<int> VideoBufferSize { get; set; }
+    public Option<int> AudioBitrate { get; set; }
+    public Option<int> AudioBufferSize { get; set; }
+    public Option<int> AudioChannels { get; set; }
+    public Option<int> AudioSampleRate { get; set; }
+    public Option<TimeSpan> AudioDuration { get; set; }
+    public string AudioCodec { get; set; }
+    public bool Deinterlace { get; set; }
+    public Option<int> VideoTrackTimeScale { get; set; }
+    public bool NormalizeLoudness { get; set; }
+    public Option<int> FrameRate { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs b/ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs
index 62b87afc2..bcee7f5e5 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegPlaybackSettingsCalculator.cs
@@ -18,284 +18,279 @@
 //    misrepresented as being the original software.
 // 3. This notice may not be removed or altered from any source distribution.
 
-using System;
-using System.Collections.Generic;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class FFmpegPlaybackSettingsCalculator
 {
-    public class FFmpegPlaybackSettingsCalculator
+    private static readonly List<string> CommonFormatFlags = new()
     {
-        private static readonly List<string> CommonFormatFlags = new()
-        {
-            "+genpts",
-            "+discardcorrupt",
-            "+igndts"
-        };
+        "+genpts",
+        "+discardcorrupt",
+        "+igndts"
+    };
 
-        private static readonly List<string> SegmenterFormatFlags = new()
-        {
-            "+discardcorrupt",
-            "+igndts"
-        };
+    private static readonly List<string> SegmenterFormatFlags = new()
+    {
+        "+discardcorrupt",
+        "+igndts"
+    };
 
-        public FFmpegPlaybackSettings ConcatSettings => new()
-        {
-            ThreadCount = 1,
-            FormatFlags = CommonFormatFlags
-        };
+    public FFmpegPlaybackSettings ConcatSettings => new()
+    {
+        ThreadCount = 1,
+        FormatFlags = CommonFormatFlags
+    };
 
-        public FFmpegPlaybackSettings CalculateSettings(
-            StreamingMode streamingMode,
-            FFmpegProfile ffmpegProfile,
-            MediaVersion videoVersion,
-            Option<MediaStream> videoStream,
-            Option<MediaStream> audioStream,
-            DateTimeOffset start,
-            DateTimeOffset now,
-            TimeSpan inPoint,
-            TimeSpan outPoint,
-            bool hlsRealtime,
-            Option<int> targetFramerate)
+    public FFmpegPlaybackSettings CalculateSettings(
+        StreamingMode streamingMode,
+        FFmpegProfile ffmpegProfile,
+        MediaVersion videoVersion,
+        Option<MediaStream> videoStream,
+        Option<MediaStream> audioStream,
+        DateTimeOffset start,
+        DateTimeOffset now,
+        TimeSpan inPoint,
+        TimeSpan outPoint,
+        bool hlsRealtime,
+        Option<int> targetFramerate)
+    {
+        var result = new FFmpegPlaybackSettings
         {
-            var result = new FFmpegPlaybackSettings
+            FormatFlags = streamingMode switch
             {
-                FormatFlags = streamingMode switch
-                {
-                    StreamingMode.HttpLiveStreamingSegmenter => SegmenterFormatFlags,
-                    _ => CommonFormatFlags,
-                },
-                RealtimeOutput = streamingMode switch
-                {
-                    StreamingMode.HttpLiveStreamingSegmenter => hlsRealtime,
-                    _ => true
-                }
-            };
-
-            // always use one thread with realtime output
-            result.ThreadCount = result.RealtimeOutput ? 1 : ffmpegProfile.ThreadCount;
-
-            if (now != start || inPoint != TimeSpan.Zero)
+                StreamingMode.HttpLiveStreamingSegmenter => SegmenterFormatFlags,
+                _ => CommonFormatFlags,
+            },
+            RealtimeOutput = streamingMode switch
             {
-                result.StreamSeek = now - start + inPoint;
+                StreamingMode.HttpLiveStreamingSegmenter => hlsRealtime,
+                _ => true
             }
+        };
 
-            switch (streamingMode)
-            {
-                case StreamingMode.HttpLiveStreamingDirect:
-                    result.AudioCodec = "copy";
-                    result.VideoCodec = "copy";
-                    result.Deinterlace = false;
-                    break;
-                case StreamingMode.TransportStreamHybrid:
-                case StreamingMode.HttpLiveStreamingSegmenter:
-                case StreamingMode.TransportStream:
-                    result.HardwareAcceleration = ffmpegProfile.HardwareAcceleration;
+        // always use one thread with realtime output
+        result.ThreadCount = result.RealtimeOutput ? 1 : ffmpegProfile.ThreadCount;
 
-                    if (NeedToScale(ffmpegProfile, videoVersion))
+        if (now != start || inPoint != TimeSpan.Zero)
+        {
+            result.StreamSeek = now - start + inPoint;
+        }
+
+        switch (streamingMode)
+        {
+            case StreamingMode.HttpLiveStreamingDirect:
+                result.AudioCodec = "copy";
+                result.VideoCodec = "copy";
+                result.Deinterlace = false;
+                break;
+            case StreamingMode.TransportStreamHybrid:
+            case StreamingMode.HttpLiveStreamingSegmenter:
+            case StreamingMode.TransportStream:
+                result.HardwareAcceleration = ffmpegProfile.HardwareAcceleration;
+
+                if (NeedToScale(ffmpegProfile, videoVersion))
+                {
+                    IDisplaySize scaledSize = CalculateScaledSize(ffmpegProfile, videoVersion);
+                    if (!scaledSize.IsSameSizeAs(videoVersion))
                     {
-                        IDisplaySize scaledSize = CalculateScaledSize(ffmpegProfile, videoVersion);
-                        if (!scaledSize.IsSameSizeAs(videoVersion))
-                        {
-                            int fixedHeight = scaledSize.Height + scaledSize.Height % 2;
-                            int fixedWidth = scaledSize.Width + scaledSize.Width % 2;
-                            result.ScaledSize = Some((IDisplaySize) new DisplaySize(fixedWidth, fixedHeight));
-                        }
+                        int fixedHeight = scaledSize.Height + scaledSize.Height % 2;
+                        int fixedWidth = scaledSize.Width + scaledSize.Width % 2;
+                        result.ScaledSize = Some((IDisplaySize) new DisplaySize(fixedWidth, fixedHeight));
+                    }
+                }
+
+                IDisplaySize sizeAfterScaling = result.ScaledSize.IfNone(videoVersion);
+                if (ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo && !sizeAfterScaling.IsSameSizeAs(ffmpegProfile.Resolution))
+                {
+                    result.PadToDesiredResolution = true;
+                }
+
+                if (ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo)
+                {
+                    if (ffmpegProfile.NormalizeFramerate)
+                    {
+                        result.FrameRate = targetFramerate;
                     }
 
-                    IDisplaySize sizeAfterScaling = result.ScaledSize.IfNone(videoVersion);
-                    if (ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo && !sizeAfterScaling.IsSameSizeAs(ffmpegProfile.Resolution))
+                    result.VideoTrackTimeScale = 90000;
+                }
+
+                foreach (MediaStream stream in videoStream.Where(s => s.AttachedPic == false))
+                {
+                    if (result.ScaledSize.IsSome || result.PadToDesiredResolution ||
+                        NeedToNormalizeVideoCodec(ffmpegProfile, stream))
                     {
-                        result.PadToDesiredResolution = true;
-                    }
+                        result.VideoCodec = ffmpegProfile.VideoCodec;
+                        result.VideoBitrate = ffmpegProfile.VideoBitrate;
+                        result.VideoBufferSize = ffmpegProfile.VideoBufferSize;
 
-                    if (ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo)
-                    {
-                        if (ffmpegProfile.NormalizeFramerate)
-                        {
-                            result.FrameRate = targetFramerate;
-                        }
-
-                        result.VideoTrackTimeScale = 90000;
-                    }
-
-                    foreach (MediaStream stream in videoStream.Where(s => s.AttachedPic == false))
-                    {
-                        if (result.ScaledSize.IsSome || result.PadToDesiredResolution ||
-                            NeedToNormalizeVideoCodec(ffmpegProfile, stream))
-                        {
-                            result.VideoCodec = ffmpegProfile.VideoCodec;
-                            result.VideoBitrate = ffmpegProfile.VideoBitrate;
-                            result.VideoBufferSize = ffmpegProfile.VideoBufferSize;
-
-                            result.VideoDecoder =
-                                (result.HardwareAcceleration, stream.Codec, stream.PixelFormat) switch
-                                {
-                                    (HardwareAccelerationKind.Nvenc, "h264", "yuv420p10le" or "yuv444p" or "yuv444p10le"
-                                        ) =>
-                                        "h264",
-                                    (HardwareAccelerationKind.Nvenc, "hevc", "yuv444p" or "yuv444p10le") => "hevc",
-                                    (HardwareAccelerationKind.Nvenc, "h264", _) => "h264_cuvid",
-                                    (HardwareAccelerationKind.Nvenc, "hevc", _) => "hevc_cuvid",
-                                    (HardwareAccelerationKind.Nvenc, "mpeg2video", _) => "mpeg2_cuvid",
-                                    (HardwareAccelerationKind.Nvenc, "mpeg4", _) => "mpeg4_cuvid",
-                                    (HardwareAccelerationKind.Qsv, "h264", _) => "h264_qsv",
-                                    (HardwareAccelerationKind.Qsv, "hevc", _) => "hevc_qsv",
-                                    (HardwareAccelerationKind.Qsv, "mpeg2video", _) => "mpeg2_qsv",
-                                    
-                                    // temp disable mpeg4 hardware decoding for all vaapi
-                                    // TODO: check for codec support
-                                    (HardwareAccelerationKind.Vaapi, "mpeg4", _) => "mpeg4",
-                                    
-                                    _ => null
-                                };
-                        }
-                        else
-                        {
-                            result.VideoCodec = "copy";
-                        }
-                    }
-
-                    if (ffmpegProfile.Transcode && ffmpegProfile.NormalizeAudio)
-                    {
-                        result.AudioCodec = ffmpegProfile.AudioCodec;
-                        result.AudioBitrate = ffmpegProfile.AudioBitrate;
-                        result.AudioBufferSize = ffmpegProfile.AudioBufferSize;
-
-                        audioStream.IfSome(
-                            stream =>
+                        result.VideoDecoder =
+                            (result.HardwareAcceleration, stream.Codec, stream.PixelFormat) switch
                             {
-                                if (stream.Channels != ffmpegProfile.AudioChannels)
-                                {
-                                    result.AudioChannels = ffmpegProfile.AudioChannels;
-                                }
-                            });
-
-                        result.AudioSampleRate = ffmpegProfile.AudioSampleRate;
-                        result.AudioDuration = outPoint - inPoint;
-                        result.NormalizeLoudness = ffmpegProfile.NormalizeLoudness;
+                                (HardwareAccelerationKind.Nvenc, "h264", "yuv420p10le" or "yuv444p" or "yuv444p10le"
+                                    ) =>
+                                    "h264",
+                                (HardwareAccelerationKind.Nvenc, "hevc", "yuv444p" or "yuv444p10le") => "hevc",
+                                (HardwareAccelerationKind.Nvenc, "h264", _) => "h264_cuvid",
+                                (HardwareAccelerationKind.Nvenc, "hevc", _) => "hevc_cuvid",
+                                (HardwareAccelerationKind.Nvenc, "mpeg2video", _) => "mpeg2_cuvid",
+                                (HardwareAccelerationKind.Nvenc, "mpeg4", _) => "mpeg4_cuvid",
+                                (HardwareAccelerationKind.Qsv, "h264", _) => "h264_qsv",
+                                (HardwareAccelerationKind.Qsv, "hevc", _) => "hevc_qsv",
+                                (HardwareAccelerationKind.Qsv, "mpeg2video", _) => "mpeg2_qsv",
+                                    
+                                // temp disable mpeg4 hardware decoding for all vaapi
+                                // TODO: check for codec support
+                                (HardwareAccelerationKind.Vaapi, "mpeg4", _) => "mpeg4",
+                                    
+                                _ => null
+                            };
                     }
                     else
                     {
-                        result.AudioCodec = "copy";
+                        result.VideoCodec = "copy";
                     }
+                }
 
-                    if (videoVersion.VideoScanKind == VideoScanKind.Interlaced)
-                    {
-                        result.Deinterlace = true;
-                    }
-
-                    break;
-            }
-
-            return result;
-        }
-
-        public FFmpegPlaybackSettings CalculateErrorSettings(FFmpegProfile ffmpegProfile)
-        {
-            string softwareCodec = ffmpegProfile.VideoCodec switch
-            {
-                { } c when c.Contains("hevc") || c.Contains("265") => "libx265",
-                { } c when c.Contains("264") => "libx264",
-                { } c when c.Contains("mpeg2") => "mpeg2video",
-                _ => "libx264"
-            };
-            
-            return new FFmpegPlaybackSettings
-            {
-                ThreadCount = ffmpegProfile.ThreadCount,
-                FormatFlags = CommonFormatFlags,
-                VideoCodec = softwareCodec,
-                AudioCodec = ffmpegProfile.AudioCodec,
-            };
-        }
-
-        private static bool NeedToScale(FFmpegProfile ffmpegProfile, MediaVersion version) =>
-            ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo &&
-            IsIncorrectSize(ffmpegProfile.Resolution, version) ||
-            IsTooLarge(ffmpegProfile.Resolution, version) ||
-            IsOddSize(version);
-
-        private static bool IsIncorrectSize(IDisplaySize desiredResolution, MediaVersion version) =>
-            IsAnamorphic(version) ||
-            version.Width != desiredResolution.Width ||
-            version.Height != desiredResolution.Height;
-
-        private static bool IsTooLarge(IDisplaySize desiredResolution, IDisplaySize displaySize) =>
-            displaySize.Height > desiredResolution.Height ||
-            displaySize.Width > desiredResolution.Width;
-
-        private static bool IsOddSize(MediaVersion version) =>
-            version.Height % 2 == 1 || version.Width % 2 == 1;
-
-        private static bool NeedToNormalizeVideoCodec(FFmpegProfile ffmpegProfile, MediaStream videoStream) =>
-            ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo && ffmpegProfile.VideoCodec != videoStream.Codec;
-
-        private static IDisplaySize CalculateScaledSize(FFmpegProfile ffmpegProfile, MediaVersion version)
-        {
-            IDisplaySize sarSize = SARSize(version);
-            int p = version.Width * sarSize.Width;
-            int q = version.Height * sarSize.Height;
-            int g = Gcd(q, p);
-            p = p / g;
-            q = q / g;
-            IDisplaySize targetSize = ffmpegProfile.Resolution;
-            int hw1 = targetSize.Width;
-            int hh1 = hw1 * q / p;
-            int hh2 = targetSize.Height;
-            int hw2 = targetSize.Height * p / q;
-            if (hh1 <= targetSize.Height)
-            {
-                return new DisplaySize(hw1, hh1);
-            }
-
-            return new DisplaySize(hw2, hh2);
-        }
-
-        private static int Gcd(int a, int b)
-        {
-            while (a != 0 && b != 0)
-            {
-                if (a > b)
+                if (ffmpegProfile.Transcode && ffmpegProfile.NormalizeAudio)
                 {
-                    a %= b;
+                    result.AudioCodec = ffmpegProfile.AudioCodec;
+                    result.AudioBitrate = ffmpegProfile.AudioBitrate;
+                    result.AudioBufferSize = ffmpegProfile.AudioBufferSize;
+
+                    audioStream.IfSome(
+                        stream =>
+                        {
+                            if (stream.Channels != ffmpegProfile.AudioChannels)
+                            {
+                                result.AudioChannels = ffmpegProfile.AudioChannels;
+                            }
+                        });
+
+                    result.AudioSampleRate = ffmpegProfile.AudioSampleRate;
+                    result.AudioDuration = outPoint - inPoint;
+                    result.NormalizeLoudness = ffmpegProfile.NormalizeLoudness;
                 }
                 else
                 {
-                    b %= a;
+                    result.AudioCodec = "copy";
                 }
-            }
 
-            return a | b;
+                if (videoVersion.VideoScanKind == VideoScanKind.Interlaced)
+                {
+                    result.Deinterlace = true;
+                }
+
+                break;
         }
 
-        private static bool IsAnamorphic(MediaVersion version)
-        {
-            if (version.SampleAspectRatio == "1:1")
-            {
-                return false;
-            }
-
-            if (version.SampleAspectRatio != "0:1")
-            {
-                return true;
-            }
-
-            if (version.DisplayAspectRatio == "0:1")
-            {
-                return false;
-            }
-
-            return version.DisplayAspectRatio != $"{version.Width}:{version.Height}";
-        }
-
-        private static IDisplaySize SARSize(MediaVersion version)
-        {
-            string[] split = version.SampleAspectRatio.Split(":");
-            return new DisplaySize(int.Parse(split[0]), int.Parse(split[1]));
-        }
+        return result;
     }
-}
+
+    public FFmpegPlaybackSettings CalculateErrorSettings(FFmpegProfile ffmpegProfile)
+    {
+        string softwareCodec = ffmpegProfile.VideoCodec switch
+        {
+            { } c when c.Contains("hevc") || c.Contains("265") => "libx265",
+            { } c when c.Contains("264") => "libx264",
+            { } c when c.Contains("mpeg2") => "mpeg2video",
+            _ => "libx264"
+        };
+            
+        return new FFmpegPlaybackSettings
+        {
+            ThreadCount = ffmpegProfile.ThreadCount,
+            FormatFlags = CommonFormatFlags,
+            VideoCodec = softwareCodec,
+            AudioCodec = ffmpegProfile.AudioCodec,
+        };
+    }
+
+    private static bool NeedToScale(FFmpegProfile ffmpegProfile, MediaVersion version) =>
+        ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo &&
+        IsIncorrectSize(ffmpegProfile.Resolution, version) ||
+        IsTooLarge(ffmpegProfile.Resolution, version) ||
+        IsOddSize(version);
+
+    private static bool IsIncorrectSize(IDisplaySize desiredResolution, MediaVersion version) =>
+        IsAnamorphic(version) ||
+        version.Width != desiredResolution.Width ||
+        version.Height != desiredResolution.Height;
+
+    private static bool IsTooLarge(IDisplaySize desiredResolution, IDisplaySize displaySize) =>
+        displaySize.Height > desiredResolution.Height ||
+        displaySize.Width > desiredResolution.Width;
+
+    private static bool IsOddSize(MediaVersion version) =>
+        version.Height % 2 == 1 || version.Width % 2 == 1;
+
+    private static bool NeedToNormalizeVideoCodec(FFmpegProfile ffmpegProfile, MediaStream videoStream) =>
+        ffmpegProfile.Transcode && ffmpegProfile.NormalizeVideo && ffmpegProfile.VideoCodec != videoStream.Codec;
+
+    private static IDisplaySize CalculateScaledSize(FFmpegProfile ffmpegProfile, MediaVersion version)
+    {
+        IDisplaySize sarSize = SARSize(version);
+        int p = version.Width * sarSize.Width;
+        int q = version.Height * sarSize.Height;
+        int g = Gcd(q, p);
+        p = p / g;
+        q = q / g;
+        IDisplaySize targetSize = ffmpegProfile.Resolution;
+        int hw1 = targetSize.Width;
+        int hh1 = hw1 * q / p;
+        int hh2 = targetSize.Height;
+        int hw2 = targetSize.Height * p / q;
+        if (hh1 <= targetSize.Height)
+        {
+            return new DisplaySize(hw1, hh1);
+        }
+
+        return new DisplaySize(hw2, hh2);
+    }
+
+    private static int Gcd(int a, int b)
+    {
+        while (a != 0 && b != 0)
+        {
+            if (a > b)
+            {
+                a %= b;
+            }
+            else
+            {
+                b %= a;
+            }
+        }
+
+        return a | b;
+    }
+
+    private static bool IsAnamorphic(MediaVersion version)
+    {
+        if (version.SampleAspectRatio == "1:1")
+        {
+            return false;
+        }
+
+        if (version.SampleAspectRatio != "0:1")
+        {
+            return true;
+        }
+
+        if (version.DisplayAspectRatio == "0:1")
+        {
+            return false;
+        }
+
+        return version.DisplayAspectRatio != $"{version.Width}:{version.Height}";
+    }
+
+    private static IDisplaySize SARSize(MediaVersion version)
+    {
+        string[] split = version.SampleAspectRatio.Split(":");
+        return new DisplaySize(int.Parse(split[0]), int.Parse(split[1]));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs b/ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs
index 48a350720..daf684036 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegProcessBuilder.cs
@@ -18,732 +18,727 @@
 //    misrepresented as being the original software.
 // 3. This notice may not be removed or altered from any source distribution.
 
-using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
-using System.IO;
 using System.Runtime.InteropServices;
 using System.Text;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+internal class FFmpegProcessBuilder
 {
-    internal class FFmpegProcessBuilder
+    private readonly List<string> _arguments = new();
+    private readonly string _ffmpegPath;
+    private readonly bool _saveReports;
+    private readonly ILogger _logger;
+    private FFmpegComplexFilterBuilder _complexFilterBuilder = new();
+    private bool _isConcat;
+    private VaapiDriver _vaapiDriver;
+    private string _vaapiDevice;
+    private HardwareAccelerationKind _hwAccel;
+    private string _outputPixelFormat;
+    private bool _noAutoScale;
+    private Option<int> _outputFramerate;
+
+    public FFmpegProcessBuilder(string ffmpegPath, bool saveReports, ILogger logger)
     {
-        private readonly List<string> _arguments = new();
-        private readonly string _ffmpegPath;
-        private readonly bool _saveReports;
-        private readonly ILogger _logger;
-        private FFmpegComplexFilterBuilder _complexFilterBuilder = new();
-        private bool _isConcat;
-        private VaapiDriver _vaapiDriver;
-        private string _vaapiDevice;
-        private HardwareAccelerationKind _hwAccel;
-        private string _outputPixelFormat;
-        private bool _noAutoScale;
-        private Option<int> _outputFramerate;
+        _ffmpegPath = ffmpegPath;
+        _saveReports = saveReports;
+        _logger = logger;
+    }
 
-        public FFmpegProcessBuilder(string ffmpegPath, bool saveReports, ILogger logger)
+    public FFmpegProcessBuilder WithVaapiDriver(VaapiDriver vaapiDriver, string vaapiDevice)
+    {
+        if (vaapiDriver != VaapiDriver.Default)
         {
-            _ffmpegPath = ffmpegPath;
-            _saveReports = saveReports;
-            _logger = logger;
+            _vaapiDriver = vaapiDriver;
         }
 
-        public FFmpegProcessBuilder WithVaapiDriver(VaapiDriver vaapiDriver, string vaapiDevice)
+        _vaapiDevice = string.IsNullOrWhiteSpace(vaapiDevice)
+            ? "/dev/dri/renderD128"
+            : vaapiDevice;
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithThreads(int threads)
+    {
+        _arguments.Add("-threads");
+        _arguments.Add($"{threads}");
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithHardwareAcceleration(HardwareAccelerationKind hwAccel, Option<string> pixelFormat, string encoder)
+    {
+        _hwAccel = hwAccel;
+
+        switch (hwAccel)
         {
-            if (vaapiDriver != VaapiDriver.Default)
-            {
-                _vaapiDriver = vaapiDriver;
-            }
-
-            _vaapiDevice = string.IsNullOrWhiteSpace(vaapiDevice)
-                ? "/dev/dri/renderD128"
-                : vaapiDevice;
-
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithThreads(int threads)
-        {
-            _arguments.Add("-threads");
-            _arguments.Add($"{threads}");
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithHardwareAcceleration(HardwareAccelerationKind hwAccel, Option<string> pixelFormat, string encoder)
-        {
-            _hwAccel = hwAccel;
-
-            switch (hwAccel)
-            {
-                case HardwareAccelerationKind.Qsv:
-                    _arguments.Add("-hwaccel");
-                    _arguments.Add("qsv");
-                    _arguments.Add("-init_hw_device");
-                    _arguments.Add("qsv=qsv:MFX_IMPL_hw_any");
-                    break;
-                case HardwareAccelerationKind.Nvenc:
-                    string outputFormat = (encoder, pixelFormat.IfNone("")) switch
-                    {
-                        ("hevc_nvenc", "yuv420p10le") => "p010le",
-                        ("h264_nvenc", "yuv420p10le") => "p010le",
-                        // ("hevc_nvenc", "yuv444p10le") => "p016le",
-                        _ => "cuda"
-                    };
+            case HardwareAccelerationKind.Qsv:
+                _arguments.Add("-hwaccel");
+                _arguments.Add("qsv");
+                _arguments.Add("-init_hw_device");
+                _arguments.Add("qsv=qsv:MFX_IMPL_hw_any");
+                break;
+            case HardwareAccelerationKind.Nvenc:
+                string outputFormat = (encoder, pixelFormat.IfNone("")) switch
+                {
+                    ("hevc_nvenc", "yuv420p10le") => "p010le",
+                    ("h264_nvenc", "yuv420p10le") => "p010le",
+                    // ("hevc_nvenc", "yuv444p10le") => "p016le",
+                    _ => "cuda"
+                };
                     
-                    _arguments.Add("-hwaccel");
-                    _arguments.Add("cuda");
-                    _arguments.Add("-hwaccel_output_format");
-                    _arguments.Add(outputFormat);
-                    break;
-                case HardwareAccelerationKind.Vaapi:
-                    _arguments.Add("-hwaccel");
-                    _arguments.Add("vaapi");
-                    _arguments.Add("-vaapi_device");
-                    _arguments.Add(_vaapiDevice);
-                    _arguments.Add("-hwaccel_output_format");
-                    _arguments.Add("vaapi");
-                    break;
-                case HardwareAccelerationKind.VideoToolbox:
-                    _arguments.Add("-hwaccel");
-                    _arguments.Add("videotoolbox");
-                    break;
-            }
-
-            _complexFilterBuilder = _complexFilterBuilder.WithHardwareAcceleration(hwAccel);
-
-            return this;
+                _arguments.Add("-hwaccel");
+                _arguments.Add("cuda");
+                _arguments.Add("-hwaccel_output_format");
+                _arguments.Add(outputFormat);
+                break;
+            case HardwareAccelerationKind.Vaapi:
+                _arguments.Add("-hwaccel");
+                _arguments.Add("vaapi");
+                _arguments.Add("-vaapi_device");
+                _arguments.Add(_vaapiDevice);
+                _arguments.Add("-hwaccel_output_format");
+                _arguments.Add("vaapi");
+                break;
+            case HardwareAccelerationKind.VideoToolbox:
+                _arguments.Add("-hwaccel");
+                _arguments.Add("videotoolbox");
+                break;
         }
 
-        public FFmpegProcessBuilder WithRealtimeOutput(bool realtimeOutput)
-        {
-            if (realtimeOutput)
-            {
-                if (!_arguments.Contains("-re"))
-                {
-                    _arguments.Add("-re");
-                }
-            }
-            else
-            {
-                _arguments.RemoveAll(s => s == "-re");
-            }
+        _complexFilterBuilder = _complexFilterBuilder.WithHardwareAcceleration(hwAccel);
 
-            return this;
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithRealtimeOutput(bool realtimeOutput)
+    {
+        if (realtimeOutput)
+        {
+            if (!_arguments.Contains("-re"))
+            {
+                _arguments.Add("-re");
+            }
+        }
+        else
+        {
+            _arguments.RemoveAll(s => s == "-re");
         }
 
-        public FFmpegProcessBuilder WithSeek(Option<TimeSpan> maybeStart)
-        {
-            maybeStart.IfSome(
-                start =>
-                {
-                    _arguments.Add("-ss");
-                    _arguments.Add($"{start:c}");
-                });
+        return this;
+    }
 
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithInfiniteLoop(bool loop = true)
-        {
-            if (loop)
+    public FFmpegProcessBuilder WithSeek(Option<TimeSpan> maybeStart)
+    {
+        maybeStart.IfSome(
+            start =>
             {
-                _arguments.Add("-stream_loop");
-                _arguments.Add("-1");
+                _arguments.Add("-ss");
+                _arguments.Add($"{start:c}");
+            });
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithInfiniteLoop(bool loop = true)
+    {
+        if (loop)
+        {
+            _arguments.Add("-stream_loop");
+            _arguments.Add("-1");
                 
-                if (_hwAccel is HardwareAccelerationKind.Qsv or HardwareAccelerationKind.Vaapi)
-                {
-                    _noAutoScale = true;
-                }
-            }
-
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithLoopedImage(string input)
-        {
-            _arguments.Add("-loop");
-            _arguments.Add("1");
-            return WithInput(input);
-        }
-
-
-        public FFmpegProcessBuilder WithPipe()
-        {
-            _arguments.Add("pipe:1");
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithPixfmt(string pixfmt)
-        {
-            _arguments.Add("-pix_fmt");
-            _arguments.Add(pixfmt);
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithLibavfilter()
-        {
-            _arguments.Add("-f");
-            _arguments.Add("lavfi");
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithInput(string input)
-        {
-            _arguments.Add("-i");
-            _arguments.Add(input);
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithMap(string map)
-        {
-            _arguments.Add("-map");
-            _arguments.Add(map);
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithCopyCodec()
-        {
-            _arguments.Add("-c");
-            _arguments.Add("copy");
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithFrameRate(Option<int> frameRate)
-        {
-            foreach (int fr in frameRate)
-            {
-                _arguments.Add("-r");
-                _arguments.Add($"{fr}");
-            
-                _arguments.Add("-vsync");
-                _arguments.Add("cfr");
-            }
-
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithWatermark(
-            Option<WatermarkOptions> watermarkOptions,
-            Option<List<FadePoint>> maybeFadePoints,
-            IDisplaySize resolution)
-        {
-            ChannelWatermarkMode maybeWatermarkMode = watermarkOptions.Map(wmo => wmo.Watermark.Map(wm => wm.Mode)).Flatten()
-                .IfNone(ChannelWatermarkMode.None);
-
-            // skip watermark if intermittent and no fade points
-            if (maybeWatermarkMode != ChannelWatermarkMode.None &&
-                (maybeWatermarkMode != ChannelWatermarkMode.Intermittent ||
-                 maybeFadePoints.Map(fp => fp.Count > 0).IfNone(false)))
-            {
-                foreach (WatermarkOptions options in watermarkOptions)
-                {
-                    foreach (string path in options.ImagePath)
-                    {
-                        if (options.IsAnimated)
-                        {
-                            _arguments.Add("-ignore_loop");
-                            _arguments.Add("0");
-                        }
-
-                        // when we have fade points, we need to loop the static watermark image
-                        else if (maybeFadePoints.Map(fp => fp.Count).IfNone(0) > 0)
-                        {
-                            _arguments.Add("-stream_loop");
-                            _arguments.Add("-1");
-                        }
-
-                        _arguments.Add("-i");
-                        _arguments.Add(path);
-
-                        _complexFilterBuilder = _complexFilterBuilder.WithWatermark(
-                            options.Watermark,
-                            maybeFadePoints,
-                            resolution,
-                            options.ImageStreamIndex);
-                    }
-                }
-            }
-
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithSubtitleFile(Option<string> subtitleFile)
-        {
-            _complexFilterBuilder = _complexFilterBuilder.WithSubtitleFile(subtitleFile);
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithInputCodec(
-            Option<TimeSpan> maybeStart,
-            bool loop,
-            string videoPath,
-            string audioPath,
-            string decoder,
-            Option<string> codec,
-            Option<string> pixelFormat,
-            bool deinterlace)
-        {
-            if (audioPath == videoPath)
-            {
-                WithSeek(maybeStart);
-                WithInfiniteLoop(loop);
-            }
-            else
+            if (_hwAccel is HardwareAccelerationKind.Qsv or HardwareAccelerationKind.Vaapi)
             {
                 _noAutoScale = true;
-                _outputFramerate = 30;
-                
-                _arguments.Add("-loop");
-                _arguments.Add("1");
             }
-
-            if (!string.IsNullOrWhiteSpace(decoder))
-            {
-                _arguments.Add("-c:v");
-                _arguments.Add(decoder);
-
-                if (decoder == "mpeg2_cuvid" && deinterlace)
-                {
-                    _arguments.Add("-deint");
-                    _arguments.Add("2");
-                }
-
-                _complexFilterBuilder = _complexFilterBuilder
-                    .WithDecoder(decoder);
-            }
-
-            _complexFilterBuilder = _complexFilterBuilder
-                .WithInputCodec(codec)
-                .WithInputPixelFormat(pixelFormat);
-
-            _arguments.Add("-i");
-            _arguments.Add(videoPath);
-
-            if (audioPath != videoPath)
-            {
-                WithSeek(maybeStart);
-
-                _arguments.Add("-i");
-                _arguments.Add(audioPath);
-            }
-
-            return this;
         }
-        
-        public FFmpegProcessBuilder WithSongInput(
-            string videoPath,
-            Option<string> codec,
-            Option<string> pixelFormat,
-            bool boxBlur)
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithLoopedImage(string input)
+    {
+        _arguments.Add("-loop");
+        _arguments.Add("1");
+        return WithInput(input);
+    }
+
+
+    public FFmpegProcessBuilder WithPipe()
+    {
+        _arguments.Add("pipe:1");
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithPixfmt(string pixfmt)
+    {
+        _arguments.Add("-pix_fmt");
+        _arguments.Add(pixfmt);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithLibavfilter()
+    {
+        _arguments.Add("-f");
+        _arguments.Add("lavfi");
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithInput(string input)
+    {
+        _arguments.Add("-i");
+        _arguments.Add(input);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithMap(string map)
+    {
+        _arguments.Add("-map");
+        _arguments.Add(map);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithCopyCodec()
+    {
+        _arguments.Add("-c");
+        _arguments.Add("copy");
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithFrameRate(Option<int> frameRate)
+    {
+        foreach (int fr in frameRate)
+        {
+            _arguments.Add("-r");
+            _arguments.Add($"{fr}");
+            
+            _arguments.Add("-vsync");
+            _arguments.Add("cfr");
+        }
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithWatermark(
+        Option<WatermarkOptions> watermarkOptions,
+        Option<List<FadePoint>> maybeFadePoints,
+        IDisplaySize resolution)
+    {
+        ChannelWatermarkMode maybeWatermarkMode = watermarkOptions.Map(wmo => wmo.Watermark.Map(wm => wm.Mode)).Flatten()
+            .IfNone(ChannelWatermarkMode.None);
+
+        // skip watermark if intermittent and no fade points
+        if (maybeWatermarkMode != ChannelWatermarkMode.None &&
+            (maybeWatermarkMode != ChannelWatermarkMode.Intermittent ||
+             maybeFadePoints.Map(fp => fp.Count > 0).IfNone(false)))
+        {
+            foreach (WatermarkOptions options in watermarkOptions)
+            {
+                foreach (string path in options.ImagePath)
+                {
+                    if (options.IsAnimated)
+                    {
+                        _arguments.Add("-ignore_loop");
+                        _arguments.Add("0");
+                    }
+
+                    // when we have fade points, we need to loop the static watermark image
+                    else if (maybeFadePoints.Map(fp => fp.Count).IfNone(0) > 0)
+                    {
+                        _arguments.Add("-stream_loop");
+                        _arguments.Add("-1");
+                    }
+
+                    _arguments.Add("-i");
+                    _arguments.Add(path);
+
+                    _complexFilterBuilder = _complexFilterBuilder.WithWatermark(
+                        options.Watermark,
+                        maybeFadePoints,
+                        resolution,
+                        options.ImageStreamIndex);
+                }
+            }
+        }
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithSubtitleFile(Option<string> subtitleFile)
+    {
+        _complexFilterBuilder = _complexFilterBuilder.WithSubtitleFile(subtitleFile);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithInputCodec(
+        Option<TimeSpan> maybeStart,
+        bool loop,
+        string videoPath,
+        string audioPath,
+        string decoder,
+        Option<string> codec,
+        Option<string> pixelFormat,
+        bool deinterlace)
+    {
+        if (audioPath == videoPath)
+        {
+            WithSeek(maybeStart);
+            WithInfiniteLoop(loop);
+        }
+        else
         {
             _noAutoScale = true;
             _outputFramerate = 30;
+                
+            _arguments.Add("-loop");
+            _arguments.Add("1");
+        }
+
+        if (!string.IsNullOrWhiteSpace(decoder))
+        {
+            _arguments.Add("-c:v");
+            _arguments.Add(decoder);
+
+            if (decoder == "mpeg2_cuvid" && deinterlace)
+            {
+                _arguments.Add("-deint");
+                _arguments.Add("2");
+            }
 
             _complexFilterBuilder = _complexFilterBuilder
-                .WithInputCodec(codec)
-                .WithInputPixelFormat(pixelFormat)
-                .WithBoxBlur(boxBlur);
+                .WithDecoder(decoder);
+        }
+
+        _complexFilterBuilder = _complexFilterBuilder
+            .WithInputCodec(codec)
+            .WithInputPixelFormat(pixelFormat);
+
+        _arguments.Add("-i");
+        _arguments.Add(videoPath);
+
+        if (audioPath != videoPath)
+        {
+            WithSeek(maybeStart);
 
             _arguments.Add("-i");
-            _arguments.Add(videoPath);
-
-            return this;
+            _arguments.Add(audioPath);
         }
 
-        public FFmpegProcessBuilder WithConcat(string concatPlaylist)
-        {
-            _isConcat = true;
+        return this;
+    }
+        
+    public FFmpegProcessBuilder WithSongInput(
+        string videoPath,
+        Option<string> codec,
+        Option<string> pixelFormat,
+        bool boxBlur)
+    {
+        _noAutoScale = true;
+        _outputFramerate = 30;
 
-            var arguments = new List<string>
+        _complexFilterBuilder = _complexFilterBuilder
+            .WithInputCodec(codec)
+            .WithInputPixelFormat(pixelFormat)
+            .WithBoxBlur(boxBlur);
+
+        _arguments.Add("-i");
+        _arguments.Add(videoPath);
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithConcat(string concatPlaylist)
+    {
+        _isConcat = true;
+
+        var arguments = new List<string>
+        {
+            "-f", "concat",
+            "-safe", "0",
+            "-protocol_whitelist", "file,http,tcp,https,tcp,tls",
+            "-probesize", "32",
+            "-i", concatPlaylist,
+            "-c", "copy",
+            "-muxdelay", "0",
+            "-muxpreload", "0"
+            // "-avoid_negative_ts", "make_zero"
+        };
+        _arguments.AddRange(arguments);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithMetadata(Channel channel, Option<MediaStream> maybeAudioStream)
+    {
+        if (channel.StreamingMode == StreamingMode.TransportStream)
+        {
+            _arguments.AddRange(new[] { "-map_metadata", "-1" });
+        }
+
+        foreach (MediaStream audioStream in maybeAudioStream)
+        {
+            if (!string.IsNullOrWhiteSpace(audioStream.Language))
             {
-                "-f", "concat",
-                "-safe", "0",
-                "-protocol_whitelist", "file,http,tcp,https,tcp,tls",
-                "-probesize", "32",
-                "-i", concatPlaylist,
-                "-c", "copy",
+                _arguments.AddRange(new[] { "-metadata:s:a:0", $"language={audioStream.Language}" });
+            }
+        }
+
+        var arguments = new List<string>
+        {
+            "-metadata", "service_provider=\"ErsatzTV\"",
+            "-metadata", $"service_name=\"{channel.Name}\""
+        };
+
+        _arguments.AddRange(arguments);
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithFormatFlags(IEnumerable<string> formatFlags)
+    {
+        _arguments.Add("-fflags");
+        _arguments.Add(string.Join(string.Empty, formatFlags));
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithDuration(TimeSpan duration)
+    {
+        _arguments.Add("-t");
+        _arguments.Add($"{duration:c}");
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithFormat(string format)
+    {
+        _arguments.Add("-f");
+        _arguments.Add($"{format}");
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithInitialDiscontinuity()
+    {
+        _arguments.Add("-mpegts_flags");
+        _arguments.Add("+initial_discontinuity");
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithHls(
+        string channelNumber,
+        Option<MediaVersion> mediaVersion,
+        long ptsOffset,
+        Option<int> maybeTimeScale,
+        Option<int> maybeFrameRate)
+    {
+        const int SEGMENT_SECONDS = 4;
+        int frameRate = maybeFrameRate.IfNone(GetFrameRateFromMediaVersion(mediaVersion));
+
+        foreach (int timescale in maybeTimeScale)
+        {
+            _arguments.Add("-output_ts_offset");
+            _arguments.Add($"{(ptsOffset / (double)timescale).ToString(NumberFormatInfo.InvariantInfo)}");
+        }
+
+        _arguments.AddRange(
+            new[]
+            {
+                "-g", $"{frameRate * SEGMENT_SECONDS}",
+                "-keyint_min", $"{frameRate * SEGMENT_SECONDS}",
+                "-force_key_frames", $"expr:gte(t,n_forced*{SEGMENT_SECONDS})",
+                "-f", "hls",
+                "-hls_time", $"{SEGMENT_SECONDS}",
+                "-hls_list_size", "0",
+                "-segment_list_flags", "+live",
+                "-hls_segment_filename",
+                Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber, "live%06d.ts"),
+                "-hls_flags", "program_date_time+append_list+discont_start+omit_endlist+independent_segments",
+                "-mpegts_flags", "+initial_discontinuity",
+                Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber, "live.m3u8")
+            });
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithPlaybackArgs(FFmpegPlaybackSettings playbackSettings)
+    {
+        var arguments = new List<string>
+        {
+            "-c:v", playbackSettings.VideoCodec,
+            "-flags", "cgop",
+            // disable scene change detection except with mpeg2video
+            "-sc_threshold", playbackSettings.VideoCodec == "mpeg2video" ? "1000000000" : "0"
+        };
+
+        if (!string.IsNullOrWhiteSpace(_outputPixelFormat))
+        {
+            arguments.AddRange(new[] { "-pix_fmt", _outputPixelFormat });
+        }
+
+        string[] videoBitrateArgs = playbackSettings.VideoBitrate.Match(
+            bitrate =>
+                new[]
+                {
+                    "-b:v", $"{bitrate}k",
+                    "-maxrate:v", $"{bitrate}k"
+                },
+            Array.Empty<string>());
+        arguments.AddRange(videoBitrateArgs);
+
+        playbackSettings.VideoBufferSize
+            .IfSome(bufferSize => arguments.AddRange(new[] { "-bufsize:v", $"{bufferSize}k" }));
+
+        string[] audioBitrateArgs = playbackSettings.AudioBitrate.Match(
+            bitrate =>
+                new[]
+                {
+                    "-b:a", $"{bitrate}k",
+                    "-maxrate:a", $"{bitrate}k"
+                },
+            Array.Empty<string>());
+        arguments.AddRange(audioBitrateArgs);
+
+        playbackSettings.AudioBufferSize
+            .IfSome(bufferSize => arguments.AddRange(new[] { "-bufsize:a", $"{bufferSize}k" }));
+
+        playbackSettings.AudioChannels
+            .IfSome(channels => arguments.AddRange(new[] { "-ac", $"{channels}" }));
+
+        playbackSettings.AudioSampleRate
+            .IfSome(sampleRate => arguments.AddRange(new[] { "-ar", $"{sampleRate}k" }));
+
+        arguments.AddRange(
+            new[]
+            {
+                "-c:a", playbackSettings.AudioCodec,
+                "-movflags", "+faststart",
                 "-muxdelay", "0",
                 "-muxpreload", "0"
-                // "-avoid_negative_ts", "make_zero"
-            };
-            _arguments.AddRange(arguments);
-            return this;
-        }
+            });
 
-        public FFmpegProcessBuilder WithMetadata(Channel channel, Option<MediaStream> maybeAudioStream)
+        _arguments.AddRange(arguments);
+
+        if (_noAutoScale)
         {
-            if (channel.StreamingMode == StreamingMode.TransportStream)
-            {
-                _arguments.AddRange(new[] { "-map_metadata", "-1" });
-            }
-
-            foreach (MediaStream audioStream in maybeAudioStream)
-            {
-                if (!string.IsNullOrWhiteSpace(audioStream.Language))
-                {
-                    _arguments.AddRange(new[] { "-metadata:s:a:0", $"language={audioStream.Language}" });
-                }
-            }
-
-            var arguments = new List<string>
-            {
-                "-metadata", "service_provider=\"ErsatzTV\"",
-                "-metadata", $"service_name=\"{channel.Name}\""
-            };
-
-            _arguments.AddRange(arguments);
-
-            return this;
+            _arguments.Add("-noautoscale");
         }
 
-        public FFmpegProcessBuilder WithFormatFlags(IEnumerable<string> formatFlags)
+        foreach (int framerate in _outputFramerate)
         {
-            _arguments.Add("-fflags");
-            _arguments.Add(string.Join(string.Empty, formatFlags));
-            return this;
+            _arguments.Add("-r");
+            _arguments.Add(framerate.ToString());
         }
 
-        public FFmpegProcessBuilder WithDuration(TimeSpan duration)
-        {
-            _arguments.Add("-t");
-            _arguments.Add($"{duration:c}");
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithFormat(string format)
-        {
-            _arguments.Add("-f");
-            _arguments.Add($"{format}");
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithInitialDiscontinuity()
-        {
-            _arguments.Add("-mpegts_flags");
-            _arguments.Add("+initial_discontinuity");
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithHls(
-            string channelNumber,
-            Option<MediaVersion> mediaVersion,
-            long ptsOffset,
-            Option<int> maybeTimeScale,
-            Option<int> maybeFrameRate)
-        {
-            const int SEGMENT_SECONDS = 4;
-            int frameRate = maybeFrameRate.IfNone(GetFrameRateFromMediaVersion(mediaVersion));
-
-            foreach (int timescale in maybeTimeScale)
-            {
-                _arguments.Add("-output_ts_offset");
-                _arguments.Add($"{(ptsOffset / (double)timescale).ToString(NumberFormatInfo.InvariantInfo)}");
-            }
-
-            _arguments.AddRange(
-                new[]
-                {
-                    "-g", $"{frameRate * SEGMENT_SECONDS}",
-                    "-keyint_min", $"{frameRate * SEGMENT_SECONDS}",
-                    "-force_key_frames", $"expr:gte(t,n_forced*{SEGMENT_SECONDS})",
-                    "-f", "hls",
-                    "-hls_time", $"{SEGMENT_SECONDS}",
-                    "-hls_list_size", "0",
-                    "-segment_list_flags", "+live",
-                    "-hls_segment_filename",
-                    Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber, "live%06d.ts"),
-                    "-hls_flags", "program_date_time+append_list+discont_start+omit_endlist+independent_segments",
-                    "-mpegts_flags", "+initial_discontinuity",
-                    Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber, "live.m3u8")
-                });
-
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithPlaybackArgs(FFmpegPlaybackSettings playbackSettings)
-        {
-            var arguments = new List<string>
-            {
-                "-c:v", playbackSettings.VideoCodec,
-                "-flags", "cgop",
-                // disable scene change detection except with mpeg2video
-                "-sc_threshold", playbackSettings.VideoCodec == "mpeg2video" ? "1000000000" : "0"
-            };
-
-            if (!string.IsNullOrWhiteSpace(_outputPixelFormat))
-            {
-                arguments.AddRange(new[] { "-pix_fmt", _outputPixelFormat });
-            }
-
-            string[] videoBitrateArgs = playbackSettings.VideoBitrate.Match(
-                bitrate =>
-                    new[]
-                    {
-                        "-b:v", $"{bitrate}k",
-                        "-maxrate:v", $"{bitrate}k"
-                    },
-                Array.Empty<string>());
-            arguments.AddRange(videoBitrateArgs);
-
-            playbackSettings.VideoBufferSize
-                .IfSome(bufferSize => arguments.AddRange(new[] { "-bufsize:v", $"{bufferSize}k" }));
-
-            string[] audioBitrateArgs = playbackSettings.AudioBitrate.Match(
-                bitrate =>
-                    new[]
-                    {
-                        "-b:a", $"{bitrate}k",
-                        "-maxrate:a", $"{bitrate}k"
-                    },
-                Array.Empty<string>());
-            arguments.AddRange(audioBitrateArgs);
-
-            playbackSettings.AudioBufferSize
-                .IfSome(bufferSize => arguments.AddRange(new[] { "-bufsize:a", $"{bufferSize}k" }));
-
-            playbackSettings.AudioChannels
-                .IfSome(channels => arguments.AddRange(new[] { "-ac", $"{channels}" }));
-
-            playbackSettings.AudioSampleRate
-                .IfSome(sampleRate => arguments.AddRange(new[] { "-ar", $"{sampleRate}k" }));
-
-            arguments.AddRange(
-                new[]
-                {
-                    "-c:a", playbackSettings.AudioCodec,
-                    "-movflags", "+faststart",
-                    "-muxdelay", "0",
-                    "-muxpreload", "0"
-                });
-
-            _arguments.AddRange(arguments);
-
-            if (_noAutoScale)
-            {
-                _arguments.Add("-noautoscale");
-            }
-
-            foreach (int framerate in _outputFramerate)
-            {
-                _arguments.Add("-r");
-                _arguments.Add(framerate.ToString());
-            }
-
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithScaling(IDisplaySize displaySize)
-        {
-            _complexFilterBuilder = _complexFilterBuilder.WithScaling(displaySize);
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithBlackBars(IDisplaySize displaySize)
-        {
-            _complexFilterBuilder = _complexFilterBuilder.WithBlackBars(displaySize);
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithAlignedAudio(Option<TimeSpan> audioDuration)
-        {
-            _complexFilterBuilder = _complexFilterBuilder.WithAlignedAudio(audioDuration);
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithNormalizeLoudness(bool normalizeLoudness)
-        {
-            _complexFilterBuilder = _complexFilterBuilder.WithNormalizeLoudness(normalizeLoudness);
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithVideoTrackTimeScale(Option<int> videoTrackTimeScale)
-        {
-            videoTrackTimeScale.IfSome(
-                timeScale =>
-                {
-                    _arguments.Add("-video_track_timescale");
-                    _arguments.Add($"{timeScale}");
-                });
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithDeinterlace(bool deinterlace)
-        {
-            _complexFilterBuilder = _complexFilterBuilder.WithDeinterlace(deinterlace);
-            return this;
-        }
-        
-        public FFmpegProcessBuilder WithOutputFormat(string format, string output)
-        {
-            _arguments.Add("-f");
-            _arguments.Add(format);
-            
-            _arguments.Add("-y");
-            _arguments.Add(output);
-
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithFilterComplex(
-            MediaStream videoStream,
-            Option<MediaStream> maybeAudioStream,
-            string videoPath,
-            Option<string> audioPath,
-            string videoCodec)
-        {
-            _complexFilterBuilder = _complexFilterBuilder.WithVideoEncoder(videoCodec);
-
-            int videoStreamIndex = videoStream.Index;
-            Option<int> maybeIndex = maybeAudioStream.Map(ms => ms.Index);
-
-            var videoIndex = 0;
-            var audioIndex = 0;
-            if (audioPath.IsNone)
-            {
-                // no audio index, so use same as video
-                audioIndex = 0;
-            }
-            else if (audioPath.IfNone("NotARealPath") != videoPath)
-            {
-                audioIndex = 1;
-                if (_hwAccel == HardwareAccelerationKind.None)
-                {
-                    _outputPixelFormat = "yuv420p";
-                }
-            }
-
-            var videoLabel = $"{videoIndex}:{videoStreamIndex}";
-            var audioLabel = $"{audioIndex}:{maybeIndex.Match(i => i.ToString(), () => "a")}";
-
-            Option<FFmpegComplexFilter> maybeFilter = _complexFilterBuilder.Build(
-                audioPath.IsNone,
-                videoIndex,
-                videoStreamIndex,
-                audioIndex,
-                maybeIndex,
-                audioPath.IsSome && videoPath != audioPath.IfNone("NotARealPath"));
-
-            maybeFilter.IfSome(
-                filter =>
-                {
-                    _arguments.Add("-filter_complex");
-                    _arguments.Add(filter.ComplexFilter);
-                    videoLabel = filter.VideoLabel;
-                    audioLabel = filter.AudioLabel;
-
-                    if (!string.IsNullOrWhiteSpace(filter.PixelFormat))
-                    {
-                        _outputPixelFormat = filter.PixelFormat;
-                    }
-                });
-
-            foreach (string _ in audioPath)
-            {
-                _arguments.Add("-map");
-                _arguments.Add(audioLabel);
-            }
-            
-            _arguments.Add("-map");
-            _arguments.Add(videoLabel);
-
-            return this;
-        }
-
-        public FFmpegProcessBuilder WithQuiet()
-        {
-            _arguments.AddRange(new[] { "-hide_banner", "-loglevel", "error", "-nostats" });
-            return this;
-        }
-
-        public Process Build()
-        {
-            var startInfo = new ProcessStartInfo
-            {
-                FileName = _ffmpegPath,
-                RedirectStandardOutput = true,
-                RedirectStandardError = false,
-                UseShellExecute = false,
-                CreateNoWindow = true,
-                StandardOutputEncoding = Encoding.UTF8
-            };
-
-            if (_hwAccel == HardwareAccelerationKind.Vaapi)
-            {
-                switch (_vaapiDriver)
-                {
-                    case VaapiDriver.i965:
-                        startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "i965";
-                        break;
-                    case VaapiDriver.iHD:
-                        startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "iHD";
-                        break;
-                    case VaapiDriver.RadeonSI:
-                        startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "radeonsi";
-                        break;
-                }
-            }
-
-            if (_saveReports)
-            {
-                string fileName = _isConcat
-                    ? Path.Combine(FileSystemLayout.FFmpegReportsFolder, "ffmpeg-%t-concat.log")
-                    : Path.Combine(FileSystemLayout.FFmpegReportsFolder, "ffmpeg-%t-transcode.log");
-
-                // rework filename in a format that works on windows
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                {
-                    // \ is escape, so use / for directory separators
-                    fileName = fileName.Replace(@"\", @"/");
-                    
-                    // colon after drive letter needs to be escaped
-                    fileName = fileName.Replace(@":/", @"\:/");
-                }
-
-                startInfo.EnvironmentVariables["FFREPORT"] = $"file={fileName}:level=32";
-            }
-
-            startInfo.ArgumentList.Add("-nostdin");
-            foreach (string argument in _arguments)
-            {
-                startInfo.ArgumentList.Add(argument);
-            }
-
-            return new Process
-            {
-                StartInfo = startInfo
-            };
-        }
-
-        private int GetFrameRateFromMediaVersion(Option<MediaVersion> mediaVersion)
-        {
-            var frameRate = 24;
-
-            foreach (MediaVersion version in mediaVersion)
-            {
-                if (!int.TryParse(version.RFrameRate, out int fr))
-                {
-                    string[] split = (version.RFrameRate ?? string.Empty).Split("/");
-                    if (int.TryParse(split[0], out int left) && int.TryParse(split[1], out int right))
-                    {
-                        fr = (int)Math.Round(left / (double)right);
-                    }
-                    else
-                    {
-                        _logger.LogInformation("Unable to detect framerate, using {FrameRate}", 24);
-                        fr = 24;
-                    }
-                }
-
-                frameRate = fr;
-            }
-
-            return frameRate;
-        }
+        return this;
     }
-}
+
+    public FFmpegProcessBuilder WithScaling(IDisplaySize displaySize)
+    {
+        _complexFilterBuilder = _complexFilterBuilder.WithScaling(displaySize);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithBlackBars(IDisplaySize displaySize)
+    {
+        _complexFilterBuilder = _complexFilterBuilder.WithBlackBars(displaySize);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithAlignedAudio(Option<TimeSpan> audioDuration)
+    {
+        _complexFilterBuilder = _complexFilterBuilder.WithAlignedAudio(audioDuration);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithNormalizeLoudness(bool normalizeLoudness)
+    {
+        _complexFilterBuilder = _complexFilterBuilder.WithNormalizeLoudness(normalizeLoudness);
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithVideoTrackTimeScale(Option<int> videoTrackTimeScale)
+    {
+        videoTrackTimeScale.IfSome(
+            timeScale =>
+            {
+                _arguments.Add("-video_track_timescale");
+                _arguments.Add($"{timeScale}");
+            });
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithDeinterlace(bool deinterlace)
+    {
+        _complexFilterBuilder = _complexFilterBuilder.WithDeinterlace(deinterlace);
+        return this;
+    }
+        
+    public FFmpegProcessBuilder WithOutputFormat(string format, string output)
+    {
+        _arguments.Add("-f");
+        _arguments.Add(format);
+            
+        _arguments.Add("-y");
+        _arguments.Add(output);
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithFilterComplex(
+        MediaStream videoStream,
+        Option<MediaStream> maybeAudioStream,
+        string videoPath,
+        Option<string> audioPath,
+        string videoCodec)
+    {
+        _complexFilterBuilder = _complexFilterBuilder.WithVideoEncoder(videoCodec);
+
+        int videoStreamIndex = videoStream.Index;
+        Option<int> maybeIndex = maybeAudioStream.Map(ms => ms.Index);
+
+        var videoIndex = 0;
+        var audioIndex = 0;
+        if (audioPath.IsNone)
+        {
+            // no audio index, so use same as video
+            audioIndex = 0;
+        }
+        else if (audioPath.IfNone("NotARealPath") != videoPath)
+        {
+            audioIndex = 1;
+            if (_hwAccel == HardwareAccelerationKind.None)
+            {
+                _outputPixelFormat = "yuv420p";
+            }
+        }
+
+        var videoLabel = $"{videoIndex}:{videoStreamIndex}";
+        var audioLabel = $"{audioIndex}:{maybeIndex.Match(i => i.ToString(), () => "a")}";
+
+        Option<FFmpegComplexFilter> maybeFilter = _complexFilterBuilder.Build(
+            audioPath.IsNone,
+            videoIndex,
+            videoStreamIndex,
+            audioIndex,
+            maybeIndex,
+            audioPath.IsSome && videoPath != audioPath.IfNone("NotARealPath"));
+
+        maybeFilter.IfSome(
+            filter =>
+            {
+                _arguments.Add("-filter_complex");
+                _arguments.Add(filter.ComplexFilter);
+                videoLabel = filter.VideoLabel;
+                audioLabel = filter.AudioLabel;
+
+                if (!string.IsNullOrWhiteSpace(filter.PixelFormat))
+                {
+                    _outputPixelFormat = filter.PixelFormat;
+                }
+            });
+
+        foreach (string _ in audioPath)
+        {
+            _arguments.Add("-map");
+            _arguments.Add(audioLabel);
+        }
+            
+        _arguments.Add("-map");
+        _arguments.Add(videoLabel);
+
+        return this;
+    }
+
+    public FFmpegProcessBuilder WithQuiet()
+    {
+        _arguments.AddRange(new[] { "-hide_banner", "-loglevel", "error", "-nostats" });
+        return this;
+    }
+
+    public Process Build()
+    {
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = _ffmpegPath,
+            RedirectStandardOutput = true,
+            RedirectStandardError = false,
+            UseShellExecute = false,
+            CreateNoWindow = true,
+            StandardOutputEncoding = Encoding.UTF8
+        };
+
+        if (_hwAccel == HardwareAccelerationKind.Vaapi)
+        {
+            switch (_vaapiDriver)
+            {
+                case VaapiDriver.i965:
+                    startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "i965";
+                    break;
+                case VaapiDriver.iHD:
+                    startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "iHD";
+                    break;
+                case VaapiDriver.RadeonSI:
+                    startInfo.EnvironmentVariables["LIBVA_DRIVER_NAME"] = "radeonsi";
+                    break;
+            }
+        }
+
+        if (_saveReports)
+        {
+            string fileName = _isConcat
+                ? Path.Combine(FileSystemLayout.FFmpegReportsFolder, "ffmpeg-%t-concat.log")
+                : Path.Combine(FileSystemLayout.FFmpegReportsFolder, "ffmpeg-%t-transcode.log");
+
+            // rework filename in a format that works on windows
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                // \ is escape, so use / for directory separators
+                fileName = fileName.Replace(@"\", @"/");
+                    
+                // colon after drive letter needs to be escaped
+                fileName = fileName.Replace(@":/", @"\:/");
+            }
+
+            startInfo.EnvironmentVariables["FFREPORT"] = $"file={fileName}:level=32";
+        }
+
+        startInfo.ArgumentList.Add("-nostdin");
+        foreach (string argument in _arguments)
+        {
+            startInfo.ArgumentList.Add(argument);
+        }
+
+        return new Process
+        {
+            StartInfo = startInfo
+        };
+    }
+
+    private int GetFrameRateFromMediaVersion(Option<MediaVersion> mediaVersion)
+    {
+        var frameRate = 24;
+
+        foreach (MediaVersion version in mediaVersion)
+        {
+            if (!int.TryParse(version.RFrameRate, out int fr))
+            {
+                string[] split = (version.RFrameRate ?? string.Empty).Split("/");
+                if (int.TryParse(split[0], out int left) && int.TryParse(split[1], out int right))
+                {
+                    fr = (int)Math.Round(left / (double)right);
+                }
+                else
+                {
+                    _logger.LogInformation("Unable to detect framerate, using {FrameRate}", 24);
+                    fr = 24;
+                }
+            }
+
+            frameRate = fr;
+        }
+
+        return frameRate;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs b/ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs
index 283a03ebb..77b95f0c6 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegProcessService.cs
@@ -1,140 +1,168 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using MediaStream = ErsatzTV.Core.Domain.MediaStream;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class FFmpegProcessService : IFFmpegProcessService
 {
-    public class FFmpegProcessService : IFFmpegProcessService
+    private readonly IFFmpegStreamSelector _ffmpegStreamSelector;
+    private readonly IImageCache _imageCache;
+    private readonly ITempFilePool _tempFilePool;
+    private readonly ILogger<FFmpegProcessService> _logger;
+    private readonly FFmpegPlaybackSettingsCalculator _playbackSettingsCalculator;
+
+    public FFmpegProcessService(
+        FFmpegPlaybackSettingsCalculator ffmpegPlaybackSettingsService,
+        IFFmpegStreamSelector ffmpegStreamSelector,
+        IImageCache imageCache,
+        ITempFilePool tempFilePool,
+        ILogger<FFmpegProcessService> logger)
     {
-        private readonly IFFmpegStreamSelector _ffmpegStreamSelector;
-        private readonly IImageCache _imageCache;
-        private readonly ITempFilePool _tempFilePool;
-        private readonly ILogger<FFmpegProcessService> _logger;
-        private readonly FFmpegPlaybackSettingsCalculator _playbackSettingsCalculator;
+        _playbackSettingsCalculator = ffmpegPlaybackSettingsService;
+        _ffmpegStreamSelector = ffmpegStreamSelector;
+        _imageCache = imageCache;
+        _tempFilePool = tempFilePool;
+        _logger = logger;
+    }
 
-        public FFmpegProcessService(
-            FFmpegPlaybackSettingsCalculator ffmpegPlaybackSettingsService,
-            IFFmpegStreamSelector ffmpegStreamSelector,
-            IImageCache imageCache,
-            ITempFilePool tempFilePool,
-            ILogger<FFmpegProcessService> logger)
-        {
-            _playbackSettingsCalculator = ffmpegPlaybackSettingsService;
-            _ffmpegStreamSelector = ffmpegStreamSelector;
-            _imageCache = imageCache;
-            _tempFilePool = tempFilePool;
-            _logger = logger;
-        }
+    public async Task<Process> ForPlayoutItem(
+        string ffmpegPath,
+        bool saveReports,
+        Channel channel,
+        MediaVersion videoVersion,
+        MediaVersion audioVersion,
+        string videoPath,
+        string audioPath,
+        DateTimeOffset start,
+        DateTimeOffset finish,
+        DateTimeOffset now,
+        Option<ChannelWatermark> globalWatermark,
+        VaapiDriver vaapiDriver,
+        string vaapiDevice,
+        bool hlsRealtime,
+        FillerKind fillerKind,
+        TimeSpan inPoint,
+        TimeSpan outPoint,
+        long ptsOffset,
+        Option<int> targetFramerate)
+    {
+        MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, videoVersion);
+        Option<MediaStream> maybeAudioStream = await _ffmpegStreamSelector.SelectAudioStream(channel, audioVersion);
 
-        public async Task<Process> ForPlayoutItem(
-            string ffmpegPath,
-            bool saveReports,
-            Channel channel,
-            MediaVersion videoVersion,
-            MediaVersion audioVersion,
-            string videoPath,
-            string audioPath,
-            DateTimeOffset start,
-            DateTimeOffset finish,
-            DateTimeOffset now,
-            Option<ChannelWatermark> globalWatermark,
-            VaapiDriver vaapiDriver,
-            string vaapiDevice,
-            bool hlsRealtime,
-            FillerKind fillerKind,
-            TimeSpan inPoint,
-            TimeSpan outPoint,
-            long ptsOffset,
-            Option<int> targetFramerate)
-        {
-            MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, videoVersion);
-            Option<MediaStream> maybeAudioStream = await _ffmpegStreamSelector.SelectAudioStream(channel, audioVersion);
+        FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.CalculateSettings(
+            channel.StreamingMode,
+            channel.FFmpegProfile,
+            videoVersion,
+            videoStream,
+            maybeAudioStream,
+            start,
+            now,
+            inPoint,
+            outPoint,
+            hlsRealtime,
+            targetFramerate);
 
-            FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.CalculateSettings(
-                channel.StreamingMode,
-                channel.FFmpegProfile,
-                videoVersion,
-                videoStream,
-                maybeAudioStream,
-                start,
-                now,
-                inPoint,
-                outPoint,
-                hlsRealtime,
-                targetFramerate);
+        Option<WatermarkOptions> watermarkOptions =
+            await GetWatermarkOptions(channel, globalWatermark, videoVersion, None, None);
 
-            Option<WatermarkOptions> watermarkOptions =
-                await GetWatermarkOptions(channel, globalWatermark, videoVersion, None, None);
+        Option<List<FadePoint>> maybeFadePoints = watermarkOptions
+            .Map(o => o.Watermark)
+            .Flatten()
+            .Where(wm => wm.Mode == ChannelWatermarkMode.Intermittent)
+            .Map(
+                wm =>
+                    WatermarkCalculator.CalculateFadePoints(
+                        start,
+                        inPoint,
+                        outPoint,
+                        playbackSettings.StreamSeek,
+                        wm.FrequencyMinutes,
+                        wm.DurationSeconds));
 
-            Option<List<FadePoint>> maybeFadePoints = watermarkOptions
-                .Map(o => o.Watermark)
-                .Flatten()
-                .Where(wm => wm.Mode == ChannelWatermarkMode.Intermittent)
-                .Map(
-                    wm =>
-                        WatermarkCalculator.CalculateFadePoints(
-                            start,
-                            inPoint,
-                            outPoint,
-                            playbackSettings.StreamSeek,
-                            wm.FrequencyMinutes,
-                            wm.DurationSeconds));
+        // foreach (List<FadePoint> fadePoints in maybeFadePoints)
+        // {
+        //     foreach (FadePoint fadePoint in fadePoints)
+        //     {
+        //         _logger.LogDebug("Fade point filter: {FadePointFilter}", fadePoint.ToFilter());
+        //     }
+        // }
 
-            // foreach (List<FadePoint> fadePoints in maybeFadePoints)
-            // {
-            //     foreach (FadePoint fadePoint in fadePoints)
-            //     {
-            //         _logger.LogDebug("Fade point filter: {FadePointFilter}", fadePoint.ToFilter());
-            //     }
-            // }
+        FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, saveReports, _logger)
+            .WithThreads(playbackSettings.ThreadCount)
+            .WithVaapiDriver(vaapiDriver, vaapiDevice)
+            .WithHardwareAcceleration(
+                playbackSettings.HardwareAcceleration,
+                videoStream.PixelFormat,
+                playbackSettings.VideoCodec)
+            .WithQuiet()
+            .WithFormatFlags(playbackSettings.FormatFlags)
+            .WithRealtimeOutput(playbackSettings.RealtimeOutput)
+            .WithInputCodec(
+                playbackSettings.StreamSeek,
+                fillerKind == FillerKind.Fallback,
+                videoPath,
+                audioPath,
+                playbackSettings.VideoDecoder,
+                videoStream.Codec,
+                videoStream.PixelFormat,
+                playbackSettings.Deinterlace)
+            .WithWatermark(watermarkOptions, maybeFadePoints, channel.FFmpegProfile.Resolution)
+            .WithFrameRate(playbackSettings.FrameRate)
+            .WithVideoTrackTimeScale(playbackSettings.VideoTrackTimeScale)
+            .WithAlignedAudio(videoPath == audioPath ? playbackSettings.AudioDuration : Option<TimeSpan>.None)
+            .WithNormalizeLoudness(playbackSettings.NormalizeLoudness);
 
-            FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, saveReports, _logger)
-                .WithThreads(playbackSettings.ThreadCount)
-                .WithVaapiDriver(vaapiDriver, vaapiDevice)
-                .WithHardwareAcceleration(
-                    playbackSettings.HardwareAcceleration,
-                    videoStream.PixelFormat,
-                    playbackSettings.VideoCodec)
-                .WithQuiet()
-                .WithFormatFlags(playbackSettings.FormatFlags)
-                .WithRealtimeOutput(playbackSettings.RealtimeOutput)
-                .WithInputCodec(
-                    playbackSettings.StreamSeek,
-                    fillerKind == FillerKind.Fallback,
-                    videoPath,
-                    audioPath,
-                    playbackSettings.VideoDecoder,
-                    videoStream.Codec,
-                    videoStream.PixelFormat,
-                    playbackSettings.Deinterlace)
-                .WithWatermark(watermarkOptions, maybeFadePoints, channel.FFmpegProfile.Resolution)
-                .WithFrameRate(playbackSettings.FrameRate)
-                .WithVideoTrackTimeScale(playbackSettings.VideoTrackTimeScale)
-                .WithAlignedAudio(videoPath == audioPath ? playbackSettings.AudioDuration : Option<TimeSpan>.None)
-                .WithNormalizeLoudness(playbackSettings.NormalizeLoudness);
+        playbackSettings.ScaledSize.Match(
+            scaledSize =>
+            {
+                builder = builder.WithDeinterlace(playbackSettings.Deinterlace)
+                    .WithScaling(scaledSize);
 
-            playbackSettings.ScaledSize.Match(
-                scaledSize =>
+                if (NeedToPad(channel.FFmpegProfile.Resolution, scaledSize))
+                {
+                    builder = builder.WithBlackBars(channel.FFmpegProfile.Resolution);
+                }
+
+                builder = builder
+                    .WithFilterComplex(
+                        videoStream,
+                        maybeAudioStream,
+                        videoPath,
+                        audioPath,
+                        channel.FFmpegProfile.VideoCodec);
+            },
+            () =>
+            {
+                if (playbackSettings.PadToDesiredResolution)
+                {
+                    builder = builder
+                        .WithDeinterlace(playbackSettings.Deinterlace)
+                        .WithBlackBars(channel.FFmpegProfile.Resolution)
+                        .WithFilterComplex(
+                            videoStream,
+                            maybeAudioStream,
+                            videoPath,
+                            audioPath,
+                            channel.FFmpegProfile.VideoCodec);
+                }
+                else if (playbackSettings.Deinterlace)
                 {
                     builder = builder.WithDeinterlace(playbackSettings.Deinterlace)
-                        .WithScaling(scaledSize);
-
-                    if (NeedToPad(channel.FFmpegProfile.Resolution, scaledSize))
-                    {
-                        builder = builder.WithBlackBars(channel.FFmpegProfile.Resolution);
-                    }
-
+                        .WithAlignedAudio(playbackSettings.AudioDuration)
+                        .WithFilterComplex(
+                            videoStream,
+                            maybeAudioStream,
+                            videoPath,
+                            audioPath,
+                            channel.FFmpegProfile.VideoCodec);
+                }
+                else
+                {
                     builder = builder
                         .WithFilterComplex(
                             videoStream,
@@ -142,371 +170,335 @@ namespace ErsatzTV.Core.FFmpeg
                             videoPath,
                             audioPath,
                             channel.FFmpegProfile.VideoCodec);
-                },
-                () =>
-                {
-                    if (playbackSettings.PadToDesiredResolution)
-                    {
-                        builder = builder
-                            .WithDeinterlace(playbackSettings.Deinterlace)
-                            .WithBlackBars(channel.FFmpegProfile.Resolution)
-                            .WithFilterComplex(
-                                videoStream,
-                                maybeAudioStream,
-                                videoPath,
-                                audioPath,
-                                channel.FFmpegProfile.VideoCodec);
-                    }
-                    else if (playbackSettings.Deinterlace)
-                    {
-                        builder = builder.WithDeinterlace(playbackSettings.Deinterlace)
-                            .WithAlignedAudio(playbackSettings.AudioDuration)
-                            .WithFilterComplex(
-                                videoStream,
-                                maybeAudioStream,
-                                videoPath,
-                                audioPath,
-                                channel.FFmpegProfile.VideoCodec);
-                    }
-                    else
-                    {
-                        builder = builder
-                            .WithFilterComplex(
-                                videoStream,
-                                maybeAudioStream,
-                                videoPath,
-                                audioPath,
-                                channel.FFmpegProfile.VideoCodec);
-                    }
-                });
+                }
+            });
 
-            builder = builder.WithPlaybackArgs(playbackSettings)
-                .WithMetadata(channel, maybeAudioStream)
-                .WithDuration(finish - now);
+        builder = builder.WithPlaybackArgs(playbackSettings)
+            .WithMetadata(channel, maybeAudioStream)
+            .WithDuration(finish - now);
 
-            return channel.StreamingMode switch
-            {
-                // HLS needs to segment and generate playlist
-                StreamingMode.HttpLiveStreamingSegmenter => builder.WithHls(
+        return channel.StreamingMode switch
+        {
+            // HLS needs to segment and generate playlist
+            StreamingMode.HttpLiveStreamingSegmenter => builder.WithHls(
+                    channel.Number,
+                    videoVersion,
+                    ptsOffset,
+                    playbackSettings.VideoTrackTimeScale,
+                    playbackSettings.FrameRate)
+                .Build(),
+            _ => builder.WithFormat("mpegts").WithInitialDiscontinuity().WithPipe().Build()
+        };
+    }
+
+    public async Task<Process> ForError(
+        string ffmpegPath,
+        Channel channel,
+        Option<TimeSpan> duration,
+        string errorMessage,
+        bool hlsRealtime,
+        long ptsOffset)
+    {
+        FFmpegPlaybackSettings playbackSettings =
+            _playbackSettingsCalculator.CalculateErrorSettings(channel.FFmpegProfile);
+
+        IDisplaySize desiredResolution = channel.FFmpegProfile.Resolution;
+
+        var fontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 20.0);
+        var margin = (int)Math.Round(channel.FFmpegProfile.Resolution.Height * 0.05);
+            
+        string subtitleFile = await new SubtitleBuilder(_tempFilePool)
+            .WithResolution(desiredResolution)
+            .WithFontName("Roboto")
+            .WithFontSize(fontSize)
+            .WithAlignment(2)
+            .WithMarginV(margin)
+            .WithPrimaryColor("&HFFFFFF")
+            .WithFormattedContent(errorMessage.Replace(Environment.NewLine, "\\N"))
+            .BuildFile();
+
+        var videoStream = new MediaStream { Index = 0 };
+        var audioStream = new MediaStream { Index = 0 };
+
+        FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, false, _logger)
+            .WithThreads(1)
+            .WithQuiet()
+            .WithFormatFlags(playbackSettings.FormatFlags)
+            .WithRealtimeOutput(playbackSettings.RealtimeOutput)
+            .WithLoopedImage(Path.Combine(FileSystemLayout.ResourcesCacheFolder, "background.png"))
+            .WithLibavfilter()
+            .WithInput("anullsrc")
+            .WithSubtitleFile(subtitleFile)
+            .WithFilterComplex(
+                videoStream,
+                audioStream,
+                Path.Combine(FileSystemLayout.ResourcesCacheFolder, "background.png"),
+                "fake-audio-path",
+                playbackSettings.VideoCodec)
+            .WithPixfmt("yuv420p")
+            .WithPlaybackArgs(playbackSettings)
+            .WithMetadata(channel, None);
+
+        await duration.IfSomeAsync(d => builder = builder.WithDuration(d));
+
+        switch (channel.StreamingMode)
+        {
+            // HLS needs to segment and generate playlist
+            case StreamingMode.HttpLiveStreamingSegmenter:
+                return builder.WithHls(
                         channel.Number,
-                        videoVersion,
+                        None,
                         ptsOffset,
                         playbackSettings.VideoTrackTimeScale,
                         playbackSettings.FrameRate)
-                    .Build(),
-                _ => builder.WithFormat("mpegts").WithInitialDiscontinuity().WithPipe().Build()
-            };
+                    .Build();
+            default:
+                return builder.WithFormat("mpegts")
+                    .WithPipe()
+                    .Build();
         }
+    }
 
-        public async Task<Process> ForError(
-            string ffmpegPath,
-            Channel channel,
-            Option<TimeSpan> duration,
-            string errorMessage,
-            bool hlsRealtime,
-            long ptsOffset)
+    public Process ConcatChannel(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host)
+    {
+        FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.ConcatSettings;
+
+        return new FFmpegProcessBuilder(ffmpegPath, saveReports, _logger)
+            .WithThreads(1)
+            .WithQuiet()
+            .WithFormatFlags(playbackSettings.FormatFlags)
+            .WithRealtimeOutput(playbackSettings.RealtimeOutput)
+            .WithInfiniteLoop()
+            .WithConcat($"http://localhost:{Settings.ListenPort}/ffmpeg/concat/{channel.Number}")
+            .WithMetadata(channel, None)
+            .WithFormat("mpegts")
+            .WithPipe()
+            .Build();
+    }
+
+    public Process WrapSegmenter(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host)
+    {
+        FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.ConcatSettings;
+
+        return new FFmpegProcessBuilder(ffmpegPath, saveReports, _logger)
+            .WithThreads(1)
+            .WithQuiet()
+            .WithFormatFlags(playbackSettings.FormatFlags)
+            .WithRealtimeOutput(true)
+            .WithInput($"http://localhost:{Settings.ListenPort}/iptv/channel/{channel.Number}.m3u8?mode=segmenter")
+            .WithMap("0")
+            .WithCopyCodec()
+            .WithMetadata(channel, None)
+            .WithFormat("mpegts")
+            .WithPipe()
+            .Build();
+    }
+
+    public Process ConvertToPng(string ffmpegPath, string inputFile, string outputFile)
+    {
+        return new FFmpegProcessBuilder(ffmpegPath, false, _logger)
+            .WithThreads(1)
+            .WithQuiet()
+            .WithInput(inputFile)
+            .WithOutputFormat("apng", outputFile)
+            .Build();
+    }
+
+    public Process ExtractAttachedPicAsPng(string ffmpegPath, string inputFile, int streamIndex, string outputFile)
+    {
+        return new FFmpegProcessBuilder(ffmpegPath, false, _logger)
+            .WithThreads(1)
+            .WithQuiet()
+            .WithInput(inputFile)
+            .WithMap($"0:{streamIndex}")
+            .WithOutputFormat("apng", outputFile)
+            .Build();
+    }
+
+    public async Task<Either<BaseError, string>> GenerateSongImage(
+        string ffmpegPath,
+        Option<string> subtitleFile,
+        Channel channel,
+        Option<ChannelWatermark> globalWatermark,
+        MediaVersion videoVersion,
+        string videoPath,
+        bool boxBlur,
+        Option<string> watermarkPath,
+        WatermarkLocation watermarkLocation,
+        int horizontalMarginPercent,
+        int verticalMarginPercent,
+        int watermarkWidthPercent)
+    {
+        try
         {
+            string outputFile = _tempFilePool.GetNextTempFile(TempFileCategory.SongBackground);
+
+            MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, videoVersion);
+
+            Option<ChannelWatermark> watermarkOverride =
+                videoVersion is FallbackMediaVersion or CoverArtMediaVersion
+                    ? new ChannelWatermark
+                    {
+                        Mode = ChannelWatermarkMode.Permanent,
+                        HorizontalMarginPercent = horizontalMarginPercent,
+                        VerticalMarginPercent = verticalMarginPercent,
+                        Location = watermarkLocation,
+                        Size = WatermarkSize.Scaled,
+                        WidthPercent = watermarkWidthPercent,
+                        Opacity = 100
+                    }
+                    : None;
+
+            Option<WatermarkOptions> watermarkOptions =
+                await GetWatermarkOptions(channel, globalWatermark, videoVersion, watermarkOverride, watermarkPath);
+
             FFmpegPlaybackSettings playbackSettings =
                 _playbackSettingsCalculator.CalculateErrorSettings(channel.FFmpegProfile);
-
-            IDisplaySize desiredResolution = channel.FFmpegProfile.Resolution;
-
-            var fontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 20.0);
-            var margin = (int)Math.Round(channel.FFmpegProfile.Resolution.Height * 0.05);
-            
-            string subtitleFile = await new SubtitleBuilder(_tempFilePool)
-                .WithResolution(desiredResolution)
-                .WithFontName("Roboto")
-                .WithFontSize(fontSize)
-                .WithAlignment(2)
-                .WithMarginV(margin)
-                .WithPrimaryColor("&HFFFFFF")
-                .WithFormattedContent(errorMessage.Replace(Environment.NewLine, "\\N"))
-                .BuildFile();
-
-            var videoStream = new MediaStream { Index = 0 };
-            var audioStream = new MediaStream { Index = 0 };
+                
+            FFmpegPlaybackSettings scalePlaybackSettings = _playbackSettingsCalculator.CalculateSettings(
+                StreamingMode.TransportStream,
+                channel.FFmpegProfile,
+                videoVersion,
+                videoStream,
+                None,
+                DateTimeOffset.UnixEpoch,
+                DateTimeOffset.UnixEpoch,
+                TimeSpan.Zero,
+                TimeSpan.Zero,
+                false,
+                Option<int>.None);
 
             FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, false, _logger)
                 .WithThreads(1)
                 .WithQuiet()
                 .WithFormatFlags(playbackSettings.FormatFlags)
-                .WithRealtimeOutput(playbackSettings.RealtimeOutput)
-                .WithLoopedImage(Path.Combine(FileSystemLayout.ResourcesCacheFolder, "background.png"))
-                .WithLibavfilter()
-                .WithInput("anullsrc")
-                .WithSubtitleFile(subtitleFile)
+                .WithSongInput(videoPath, videoStream.Codec, videoStream.PixelFormat, boxBlur)
+                .WithWatermark(watermarkOptions, None, channel.FFmpegProfile.Resolution)
+                .WithSubtitleFile(subtitleFile);
+
+            foreach (IDisplaySize scaledSize in scalePlaybackSettings.ScaledSize)
+            {
+                builder = builder.WithScaling(scaledSize);
+                    
+                if (NeedToPad(channel.FFmpegProfile.Resolution, scaledSize))
+                {
+                    builder = builder.WithBlackBars(channel.FFmpegProfile.Resolution);
+                }
+            }
+
+            using Process process = builder
                 .WithFilterComplex(
-                    videoStream,
-                    audioStream,
-                    Path.Combine(FileSystemLayout.ResourcesCacheFolder, "background.png"),
-                    "fake-audio-path",
-                    playbackSettings.VideoCodec)
-                .WithPixfmt("yuv420p")
-                .WithPlaybackArgs(playbackSettings)
-                .WithMetadata(channel, None);
-
-            await duration.IfSomeAsync(d => builder = builder.WithDuration(d));
-
-            switch (channel.StreamingMode)
-            {
-                // HLS needs to segment and generate playlist
-                case StreamingMode.HttpLiveStreamingSegmenter:
-                    return builder.WithHls(
-                            channel.Number,
-                            None,
-                            ptsOffset,
-                            playbackSettings.VideoTrackTimeScale,
-                            playbackSettings.FrameRate)
-                        .Build();
-                default:
-                    return builder.WithFormat("mpegts")
-                        .WithPipe()
-                        .Build();
-            }
-        }
-
-        public Process ConcatChannel(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host)
-        {
-            FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.ConcatSettings;
-
-            return new FFmpegProcessBuilder(ffmpegPath, saveReports, _logger)
-                .WithThreads(1)
-                .WithQuiet()
-                .WithFormatFlags(playbackSettings.FormatFlags)
-                .WithRealtimeOutput(playbackSettings.RealtimeOutput)
-                .WithInfiniteLoop()
-                .WithConcat($"http://localhost:{Settings.ListenPort}/ffmpeg/concat/{channel.Number}")
-                .WithMetadata(channel, None)
-                .WithFormat("mpegts")
-                .WithPipe()
-                .Build();
-        }
-
-        public Process WrapSegmenter(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host)
-        {
-            FFmpegPlaybackSettings playbackSettings = _playbackSettingsCalculator.ConcatSettings;
-
-            return new FFmpegProcessBuilder(ffmpegPath, saveReports, _logger)
-                .WithThreads(1)
-                .WithQuiet()
-                .WithFormatFlags(playbackSettings.FormatFlags)
-                .WithRealtimeOutput(true)
-                .WithInput($"http://localhost:{Settings.ListenPort}/iptv/channel/{channel.Number}.m3u8?mode=segmenter")
-                .WithMap("0")
-                .WithCopyCodec()
-                .WithMetadata(channel, None)
-                .WithFormat("mpegts")
-                .WithPipe()
-                .Build();
-        }
-
-        public Process ConvertToPng(string ffmpegPath, string inputFile, string outputFile)
-        {
-            return new FFmpegProcessBuilder(ffmpegPath, false, _logger)
-                .WithThreads(1)
-                .WithQuiet()
-                .WithInput(inputFile)
-                .WithOutputFormat("apng", outputFile)
-                .Build();
-        }
-
-        public Process ExtractAttachedPicAsPng(string ffmpegPath, string inputFile, int streamIndex, string outputFile)
-        {
-            return new FFmpegProcessBuilder(ffmpegPath, false, _logger)
-                .WithThreads(1)
-                .WithQuiet()
-                .WithInput(inputFile)
-                .WithMap($"0:{streamIndex}")
-                .WithOutputFormat("apng", outputFile)
-                .Build();
-        }
-
-        public async Task<Either<BaseError, string>> GenerateSongImage(
-            string ffmpegPath,
-            Option<string> subtitleFile,
-            Channel channel,
-            Option<ChannelWatermark> globalWatermark,
-            MediaVersion videoVersion,
-            string videoPath,
-            bool boxBlur,
-            Option<string> watermarkPath,
-            WatermarkLocation watermarkLocation,
-            int horizontalMarginPercent,
-            int verticalMarginPercent,
-            int watermarkWidthPercent)
-        {
-            try
-            {
-                string outputFile = _tempFilePool.GetNextTempFile(TempFileCategory.SongBackground);
-
-                MediaStream videoStream = await _ffmpegStreamSelector.SelectVideoStream(channel, videoVersion);
-
-                Option<ChannelWatermark> watermarkOverride =
-                    videoVersion is FallbackMediaVersion or CoverArtMediaVersion
-                        ? new ChannelWatermark
-                        {
-                            Mode = ChannelWatermarkMode.Permanent,
-                            HorizontalMarginPercent = horizontalMarginPercent,
-                            VerticalMarginPercent = verticalMarginPercent,
-                            Location = watermarkLocation,
-                            Size = WatermarkSize.Scaled,
-                            WidthPercent = watermarkWidthPercent,
-                            Opacity = 100
-                        }
-                        : None;
-
-                Option<WatermarkOptions> watermarkOptions =
-                    await GetWatermarkOptions(channel, globalWatermark, videoVersion, watermarkOverride, watermarkPath);
-
-                FFmpegPlaybackSettings playbackSettings =
-                    _playbackSettingsCalculator.CalculateErrorSettings(channel.FFmpegProfile);
-                
-                FFmpegPlaybackSettings scalePlaybackSettings = _playbackSettingsCalculator.CalculateSettings(
-                    StreamingMode.TransportStream,
-                    channel.FFmpegProfile,
-                    videoVersion,
                     videoStream,
                     None,
-                    DateTimeOffset.UnixEpoch,
-                    DateTimeOffset.UnixEpoch,
-                    TimeSpan.Zero,
-                    TimeSpan.Zero,
-                    false,
-                    Option<int>.None);
+                    videoPath,
+                    None,
+                    playbackSettings.VideoCodec)
+                .WithOutputFormat("apng", outputFile)
+                .Build();
 
-                FFmpegProcessBuilder builder = new FFmpegProcessBuilder(ffmpegPath, false, _logger)
-                    .WithThreads(1)
-                    .WithQuiet()
-                    .WithFormatFlags(playbackSettings.FormatFlags)
-                    .WithSongInput(videoPath, videoStream.Codec, videoStream.PixelFormat, boxBlur)
-                    .WithWatermark(watermarkOptions, None, channel.FFmpegProfile.Resolution)
-                    .WithSubtitleFile(subtitleFile);
+            _logger.LogInformation(
+                "ffmpeg song arguments {FFmpegArguments}",
+                string.Join(" ", process.StartInfo.ArgumentList));
 
-                foreach (IDisplaySize scaledSize in scalePlaybackSettings.ScaledSize)
-                {
-                    builder = builder.WithScaling(scaledSize);
-                    
-                    if (NeedToPad(channel.FFmpegProfile.Resolution, scaledSize))
-                    {
-                        builder = builder.WithBlackBars(channel.FFmpegProfile.Resolution);
-                    }
-                }
+            process.Start();
+            await process.WaitForExitAsync();
 
-                using Process process = builder
-                    .WithFilterComplex(
-                        videoStream,
-                        None,
-                        videoPath,
-                        None,
-                        playbackSettings.VideoCodec)
-                    .WithOutputFormat("apng", outputFile)
-                    .Build();
-
-                _logger.LogInformation(
-                    "ffmpeg song arguments {FFmpegArguments}",
-                    string.Join(" ", process.StartInfo.ArgumentList));
-
-                process.Start();
-                await process.WaitForExitAsync();
-
-                return outputFile;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error generating song image");
-                return Left(BaseError.New(ex.Message));
-            }
+            return outputFile;
         }
-
-        private bool NeedToPad(IDisplaySize target, IDisplaySize displaySize) =>
-            displaySize.Width != target.Width || displaySize.Height != target.Height;
-
-        internal async Task<WatermarkOptions> GetWatermarkOptions(
-            Channel channel,
-            Option<ChannelWatermark> globalWatermark,
-            MediaVersion videoVersion,
-            Option<ChannelWatermark> watermarkOverride,
-            Option<string> watermarkPath)
+        catch (Exception ex)
         {
-            if (channel.StreamingMode != StreamingMode.HttpLiveStreamingDirect && channel.FFmpegProfile.Transcode &&
-                channel.FFmpegProfile.NormalizeVideo)
-            {
-                if (videoVersion is CoverArtMediaVersion)
-                {
-                    return new WatermarkOptions(
-                        watermarkOverride,
-                        await watermarkPath.IfNoneAsync(videoVersion.MediaFiles.Head().Path),
-                        0,
-                        false);
-                }
-
-                // check for channel watermark
-                if (channel.Watermark != null)
-                {
-                    switch (channel.Watermark.ImageSource)
-                    {
-                        case ChannelWatermarkImageSource.Custom:
-                            string customPath = _imageCache.GetPathForImage(
-                                channel.Watermark.Image,
-                                ArtworkKind.Watermark,
-                                Option<int>.None);
-                            return new WatermarkOptions(
-                                await watermarkOverride.IfNoneAsync(channel.Watermark),
-                                customPath,
-                                None,
-                                await _imageCache.IsAnimated(customPath));
-                        case ChannelWatermarkImageSource.ChannelLogo:
-                            Option<string> maybeChannelPath = channel.Artwork
-                                .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
-                                .HeadOrNone()
-                                .Map(a => _imageCache.GetPathForImage(a.Path, ArtworkKind.Logo, Option<int>.None));
-                            return new WatermarkOptions(
-                                await watermarkOverride.IfNoneAsync(channel.Watermark),
-                                maybeChannelPath,
-                                None,
-                                await maybeChannelPath.Match(
-                                    p => _imageCache.IsAnimated(p),
-                                    () => Task.FromResult(false)));
-                        default:
-                            throw new NotSupportedException("Unsupported watermark image source");
-                    }
-                }
-
-                // check for global watermark
-                foreach (ChannelWatermark watermark in globalWatermark)
-                {
-                    switch (watermark.ImageSource)
-                    {
-                        case ChannelWatermarkImageSource.Custom:
-                            string customPath = _imageCache.GetPathForImage(
-                                watermark.Image,
-                                ArtworkKind.Watermark,
-                                Option<int>.None);
-                            return new WatermarkOptions(
-                                await watermarkOverride.IfNoneAsync(watermark),
-                                customPath,
-                                None,
-                                await _imageCache.IsAnimated(customPath));
-                        case ChannelWatermarkImageSource.ChannelLogo:
-                            Option<string> maybeChannelPath = channel.Artwork
-                                .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
-                                .HeadOrNone()
-                                .Map(a => _imageCache.GetPathForImage(a.Path, ArtworkKind.Logo, Option<int>.None));
-                            return new WatermarkOptions(
-                                await watermarkOverride.IfNoneAsync(watermark),
-                                maybeChannelPath,
-                                None,
-                                await maybeChannelPath.Match(
-                                    p => _imageCache.IsAnimated(p),
-                                    () => Task.FromResult(false)));
-                        default:
-                            throw new NotSupportedException("Unsupported watermark image source");
-                    }
-                }
-            }
-
-            return new WatermarkOptions(None, None, None, false);
+            _logger.LogWarning(ex, "Error generating song image");
+            return Left(BaseError.New(ex.Message));
         }
     }
-}
+
+    private bool NeedToPad(IDisplaySize target, IDisplaySize displaySize) =>
+        displaySize.Width != target.Width || displaySize.Height != target.Height;
+
+    internal async Task<WatermarkOptions> GetWatermarkOptions(
+        Channel channel,
+        Option<ChannelWatermark> globalWatermark,
+        MediaVersion videoVersion,
+        Option<ChannelWatermark> watermarkOverride,
+        Option<string> watermarkPath)
+    {
+        if (channel.StreamingMode != StreamingMode.HttpLiveStreamingDirect && channel.FFmpegProfile.Transcode &&
+            channel.FFmpegProfile.NormalizeVideo)
+        {
+            if (videoVersion is CoverArtMediaVersion)
+            {
+                return new WatermarkOptions(
+                    watermarkOverride,
+                    await watermarkPath.IfNoneAsync(videoVersion.MediaFiles.Head().Path),
+                    0,
+                    false);
+            }
+
+            // check for channel watermark
+            if (channel.Watermark != null)
+            {
+                switch (channel.Watermark.ImageSource)
+                {
+                    case ChannelWatermarkImageSource.Custom:
+                        string customPath = _imageCache.GetPathForImage(
+                            channel.Watermark.Image,
+                            ArtworkKind.Watermark,
+                            Option<int>.None);
+                        return new WatermarkOptions(
+                            await watermarkOverride.IfNoneAsync(channel.Watermark),
+                            customPath,
+                            None,
+                            await _imageCache.IsAnimated(customPath));
+                    case ChannelWatermarkImageSource.ChannelLogo:
+                        Option<string> maybeChannelPath = channel.Artwork
+                            .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
+                            .HeadOrNone()
+                            .Map(a => _imageCache.GetPathForImage(a.Path, ArtworkKind.Logo, Option<int>.None));
+                        return new WatermarkOptions(
+                            await watermarkOverride.IfNoneAsync(channel.Watermark),
+                            maybeChannelPath,
+                            None,
+                            await maybeChannelPath.Match(
+                                p => _imageCache.IsAnimated(p),
+                                () => Task.FromResult(false)));
+                    default:
+                        throw new NotSupportedException("Unsupported watermark image source");
+                }
+            }
+
+            // check for global watermark
+            foreach (ChannelWatermark watermark in globalWatermark)
+            {
+                switch (watermark.ImageSource)
+                {
+                    case ChannelWatermarkImageSource.Custom:
+                        string customPath = _imageCache.GetPathForImage(
+                            watermark.Image,
+                            ArtworkKind.Watermark,
+                            Option<int>.None);
+                        return new WatermarkOptions(
+                            await watermarkOverride.IfNoneAsync(watermark),
+                            customPath,
+                            None,
+                            await _imageCache.IsAnimated(customPath));
+                    case ChannelWatermarkImageSource.ChannelLogo:
+                        Option<string> maybeChannelPath = channel.Artwork
+                            .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
+                            .HeadOrNone()
+                            .Map(a => _imageCache.GetPathForImage(a.Path, ArtworkKind.Logo, Option<int>.None));
+                        return new WatermarkOptions(
+                            await watermarkOverride.IfNoneAsync(watermark),
+                            maybeChannelPath,
+                            None,
+                            await maybeChannelPath.Match(
+                                p => _imageCache.IsAnimated(p),
+                                () => Task.FromResult(false)));
+                    default:
+                        throw new NotSupportedException("Unsupported watermark image source");
+                }
+            }
+        }
+
+        return new WatermarkOptions(None, None, None, false);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegProcessServiceFactory.cs b/ErsatzTV.Core/FFmpeg/FFmpegProcessServiceFactory.cs
index 0ff3429e3..baee4efdc 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegProcessServiceFactory.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegProcessServiceFactory.cs
@@ -1,9 +1,6 @@
-using System;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace ErsatzTV.Core.FFmpeg;
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegSegmenterService.cs b/ErsatzTV.Core/FFmpeg/FFmpegSegmenterService.cs
index c3229862e..d28293de6 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegSegmenterService.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegSegmenterService.cs
@@ -1,23 +1,22 @@
 using System.Collections.Concurrent;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class FFmpegSegmenterService : IFFmpegSegmenterService
 {
-    public class FFmpegSegmenterService : IFFmpegSegmenterService
+    public FFmpegSegmenterService()
     {
-        public FFmpegSegmenterService()
-        {
-            SessionWorkers = new ConcurrentDictionary<string, IHlsSessionWorker>();
-        }
+        SessionWorkers = new ConcurrentDictionary<string, IHlsSessionWorker>();
+    }
 
-        public ConcurrentDictionary<string, IHlsSessionWorker> SessionWorkers { get; }
+    public ConcurrentDictionary<string, IHlsSessionWorker> SessionWorkers { get; }
 
-        public void TouchChannel(string channelNumber)
+    public void TouchChannel(string channelNumber)
+    {
+        if (SessionWorkers.TryGetValue(channelNumber, out IHlsSessionWorker worker))
         {
-            if (SessionWorkers.TryGetValue(channelNumber, out IHlsSessionWorker worker))
-            {
-                worker?.Touch();
-            }
+            worker?.Touch();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FFmpegStreamSelector.cs b/ErsatzTV.Core/FFmpeg/FFmpegStreamSelector.cs
index a813c914b..46b60d702 100644
--- a/ErsatzTV.Core/FFmpeg/FFmpegStreamSelector.cs
+++ b/ErsatzTV.Core/FFmpeg/FFmpegStreamSelector.cs
@@ -1,90 +1,83 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class FFmpegStreamSelector : IFFmpegStreamSelector
 {
-    public class FFmpegStreamSelector : IFFmpegStreamSelector
-    {
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly ISearchRepository _searchRepository;
-        private readonly ILogger<FFmpegStreamSelector> _logger;
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly ISearchRepository _searchRepository;
+    private readonly ILogger<FFmpegStreamSelector> _logger;
 
-        public FFmpegStreamSelector(
-            ISearchRepository searchRepository,
-            ILogger<FFmpegStreamSelector> logger,
-            IConfigElementRepository configElementRepository)
+    public FFmpegStreamSelector(
+        ISearchRepository searchRepository,
+        ILogger<FFmpegStreamSelector> logger,
+        IConfigElementRepository configElementRepository)
+    {
+        _searchRepository = searchRepository;
+        _logger = logger;
+        _configElementRepository = configElementRepository;
+    }
+
+    public Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version) =>
+        version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Video).AsTask();
+
+    public async Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version)
+    {
+        if (channel.StreamingMode == StreamingMode.HttpLiveStreamingDirect &&
+            string.IsNullOrWhiteSpace(channel.PreferredLanguageCode))
         {
-            _searchRepository = searchRepository;
-            _logger = logger;
-            _configElementRepository = configElementRepository;
+            _logger.LogDebug(
+                "Channel {Number} is HLS with no preferred language; using all audio streams",
+                channel.Number);
+            return None;
         }
 
-        public Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version) =>
-            version.Streams.First(s => s.MediaStreamKind == MediaStreamKind.Video).AsTask();
+        var audioStreams = version.Streams.Filter(s => s.MediaStreamKind == MediaStreamKind.Audio).ToList();
 
-        public async Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version)
+        string language = (channel.PreferredLanguageCode ?? string.Empty).ToLowerInvariant();
+        if (string.IsNullOrWhiteSpace(language))
         {
-            if (channel.StreamingMode == StreamingMode.HttpLiveStreamingDirect &&
-                string.IsNullOrWhiteSpace(channel.PreferredLanguageCode))
-            {
-                _logger.LogDebug(
-                    "Channel {Number} is HLS with no preferred language; using all audio streams",
-                    channel.Number);
-                return None;
-            }
+            _logger.LogDebug("Channel {Number} has no preferred language code", channel.Number);
+            Option<string> maybeDefaultLanguage = await _configElementRepository.GetValue<string>(
+                ConfigElementKey.FFmpegPreferredLanguageCode);
+            maybeDefaultLanguage.Match(
+                lang => language = lang.ToLowerInvariant(),
+                () =>
+                {
+                    _logger.LogDebug("FFmpeg has no preferred language code; falling back to {Code}", "eng");
+                    language = "eng";
+                });
+        }
 
-            var audioStreams = version.Streams.Filter(s => s.MediaStreamKind == MediaStreamKind.Audio).ToList();
-
-            string language = (channel.PreferredLanguageCode ?? string.Empty).ToLowerInvariant();
-            if (string.IsNullOrWhiteSpace(language))
-            {
-                _logger.LogDebug("Channel {Number} has no preferred language code", channel.Number);
-                Option<string> maybeDefaultLanguage = await _configElementRepository.GetValue<string>(
-                    ConfigElementKey.FFmpegPreferredLanguageCode);
-                maybeDefaultLanguage.Match(
-                    lang => language = lang.ToLowerInvariant(),
-                    () =>
-                    {
-                        _logger.LogDebug("FFmpeg has no preferred language code; falling back to {Code}", "eng");
-                        language = "eng";
-                    });
-            }
-
-            List<string> allCodes = await _searchRepository.GetAllLanguageCodes(new List<string> { language });
-            if (allCodes.Count > 1)
-            {
-                _logger.LogDebug("Preferred language has multiple codes {Codes}", allCodes);
-            }
-
-            var correctLanguage = audioStreams.Filter(
-                s => allCodes.Any(
-                    c => string.Equals(
-                        s.Language,
-                        c,
-                        StringComparison.InvariantCultureIgnoreCase))).ToList();
-            if (correctLanguage.Any())
-            {
-                _logger.LogDebug(
-                    "Found {Count} audio streams with preferred language code(s) {Code}; selecting stream with most channels",
-                    correctLanguage.Count,
-                    allCodes);
-
-                return correctLanguage.OrderByDescending(s => s.Channels).Head();
-            }
+        List<string> allCodes = await _searchRepository.GetAllLanguageCodes(new List<string> { language });
+        if (allCodes.Count > 1)
+        {
+            _logger.LogDebug("Preferred language has multiple codes {Codes}", allCodes);
+        }
 
+        var correctLanguage = audioStreams.Filter(
+            s => allCodes.Any(
+                c => string.Equals(
+                    s.Language,
+                    c,
+                    StringComparison.InvariantCultureIgnoreCase))).ToList();
+        if (correctLanguage.Any())
+        {
             _logger.LogDebug(
-                "Unable to find audio stream with preferred language code(s) {Code}; selecting stream with most channels",
+                "Found {Count} audio streams with preferred language code(s) {Code}; selecting stream with most channels",
+                correctLanguage.Count,
                 allCodes);
 
-            return audioStreams.OrderByDescending(s => s.Channels).Head();
+            return correctLanguage.OrderByDescending(s => s.Channels).Head();
         }
+
+        _logger.LogDebug(
+            "Unable to find audio stream with preferred language code(s) {Code}; selecting stream with most channels",
+            allCodes);
+
+        return audioStreams.OrderByDescending(s => s.Channels).Head();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/FadePoint.cs b/ErsatzTV.Core/FFmpeg/FadePoint.cs
index 391987827..47e78121c 100644
--- a/ErsatzTV.Core/FFmpeg/FadePoint.cs
+++ b/ErsatzTV.Core/FFmpeg/FadePoint.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Globalization;
+using System.Globalization;
 
 namespace ErsatzTV.Core.FFmpeg;
 
diff --git a/ErsatzTV.Core/FFmpeg/HlsPlaylistFilter.cs b/ErsatzTV.Core/FFmpeg/HlsPlaylistFilter.cs
index 6844dc69d..613947a87 100644
--- a/ErsatzTV.Core/FFmpeg/HlsPlaylistFilter.cs
+++ b/ErsatzTV.Core/FFmpeg/HlsPlaylistFilter.cs
@@ -1,151 +1,148 @@
-using System;
-using System.Globalization;
-using System.IO;
+using System.Globalization;
 using System.Text;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class HlsPlaylistFilter : IHlsPlaylistFilter
 {
-    public class HlsPlaylistFilter : IHlsPlaylistFilter
+    private readonly ITempFilePool _tempFilePool;
+    private readonly ILogger<HlsPlaylistFilter> _logger;
+
+    public HlsPlaylistFilter(ITempFilePool tempFilePool, ILogger<HlsPlaylistFilter> logger)
     {
-        private readonly ITempFilePool _tempFilePool;
-        private readonly ILogger<HlsPlaylistFilter> _logger;
+        _tempFilePool = tempFilePool;
+        _logger = logger;
+    }
 
-        public HlsPlaylistFilter(ITempFilePool tempFilePool, ILogger<HlsPlaylistFilter> logger)
+    public TrimPlaylistResult TrimPlaylist(
+        DateTimeOffset playlistStart,
+        DateTimeOffset filterBefore,
+        string[] lines,
+        int maxSegments = 10,
+        bool endWithDiscontinuity = false)
+    {
+        try
         {
-            _tempFilePool = tempFilePool;
-            _logger = logger;
-        }
+            DateTimeOffset currentTime = playlistStart;
+            DateTimeOffset nextPlaylistStart = DateTimeOffset.MaxValue;
 
-        public TrimPlaylistResult TrimPlaylist(
-            DateTimeOffset playlistStart,
-            DateTimeOffset filterBefore,
-            string[] lines,
-            int maxSegments = 10,
-            bool endWithDiscontinuity = false)
-        {
-            try
+            var discontinuitySequence = 0;
+            var startSequence = 0;
+            var output = new StringBuilder();
+            var started = false;
+            var i = 0;
+            var segments = 0;
+            while (!lines[i].StartsWith("#EXTINF:"))
             {
-                DateTimeOffset currentTime = playlistStart;
-                DateTimeOffset nextPlaylistStart = DateTimeOffset.MaxValue;
-
-                var discontinuitySequence = 0;
-                var startSequence = 0;
-                var output = new StringBuilder();
-                var started = false;
-                var i = 0;
-                var segments = 0;
-                while (!lines[i].StartsWith("#EXTINF:"))
+                if (lines[i].StartsWith("#EXT-X-DISCONTINUITY-SEQUENCE"))
                 {
-                    if (lines[i].StartsWith("#EXT-X-DISCONTINUITY-SEQUENCE"))
+                    discontinuitySequence = int.Parse(lines[i].Split(':')[1]);
+                }
+
+                i++;
+            }
+
+            while (i < lines.Length)
+            {
+                if (segments >= maxSegments)
+                {
+                    break;
+                }
+
+                string line = lines[i];
+                // _logger.LogInformation("Line: {Line}", line);
+                if (line.StartsWith("#EXT-X-DISCONTINUITY"))
+                {
+                    if (started)
                     {
-                        discontinuitySequence = int.Parse(lines[i].Split(':')[1]);
+                        output.AppendLine("#EXT-X-DISCONTINUITY");
+                    }
+                    else
+                    {
+                        discontinuitySequence++;
                     }
 
                     i++;
+                    continue;
                 }
 
-                while (i < lines.Length)
+                var duration = TimeSpan.FromSeconds(
+                    double.Parse(
+                        lines[i].TrimEnd(',').Split(':')[1],
+                        NumberStyles.Number,
+                        CultureInfo.InvariantCulture));
+                if (currentTime < filterBefore)
                 {
-                    if (segments >= maxSegments)
-                    {
-                        break;
-                    }
-
-                    string line = lines[i];
-                    // _logger.LogInformation("Line: {Line}", line);
-                    if (line.StartsWith("#EXT-X-DISCONTINUITY"))
-                    {
-                        if (started)
-                        {
-                            output.AppendLine("#EXT-X-DISCONTINUITY");
-                        }
-                        else
-                        {
-                            discontinuitySequence++;
-                        }
-
-                        i++;
-                        continue;
-                    }
-
-                    var duration = TimeSpan.FromSeconds(
-                        double.Parse(
-                            lines[i].TrimEnd(',').Split(':')[1],
-                            NumberStyles.Number,
-                            CultureInfo.InvariantCulture));
-                    if (currentTime < filterBefore)
-                    {
-                        currentTime += duration;
-                        i += 3;
-                        continue;
-                    }
-
-                    nextPlaylistStart = currentTime < nextPlaylistStart ? currentTime : nextPlaylistStart;
-
-                    if (!started)
-                    {
-                        startSequence = int.Parse(lines[i + 2].Replace("live", string.Empty).Split('.')[0]);
-
-                        output.AppendLine("#EXTM3U");
-                        output.AppendLine("#EXT-X-VERSION:6");
-                        output.AppendLine("#EXT-X-TARGETDURATION:4");
-                        output.AppendLine($"#EXT-X-MEDIA-SEQUENCE:{startSequence}");
-                        output.AppendLine($"#EXT-X-DISCONTINUITY-SEQUENCE:{discontinuitySequence}");
-                        output.AppendLine("#EXT-X-INDEPENDENT-SEGMENTS");
-                        output.AppendLine("#EXT-X-DISCONTINUITY");
-
-                        started = true;
-                    }
-
-                    output.AppendLine(lines[i]);
-                    string offset = currentTime.ToString("zzz").Replace(":", string.Empty);
-                    output.AppendLine($"#EXT-X-PROGRAM-DATE-TIME:{currentTime:yyyy-MM-ddTHH:mm:ss.fff}{offset}");
-                    output.AppendLine(lines[i + 2]);
-
                     currentTime += duration;
-                    segments++;
                     i += 3;
+                    continue;
                 }
 
-                var playlist = output.ToString();
-                if (endWithDiscontinuity && !playlist.EndsWith($"#EXT-X-DISCONTINUITY{Environment.NewLine}"))
+                nextPlaylistStart = currentTime < nextPlaylistStart ? currentTime : nextPlaylistStart;
+
+                if (!started)
                 {
-                    playlist += "#EXT-X-DISCONTINUITY" + Environment.NewLine;
+                    startSequence = int.Parse(lines[i + 2].Replace("live", string.Empty).Split('.')[0]);
+
+                    output.AppendLine("#EXTM3U");
+                    output.AppendLine("#EXT-X-VERSION:6");
+                    output.AppendLine("#EXT-X-TARGETDURATION:4");
+                    output.AppendLine($"#EXT-X-MEDIA-SEQUENCE:{startSequence}");
+                    output.AppendLine($"#EXT-X-DISCONTINUITY-SEQUENCE:{discontinuitySequence}");
+                    output.AppendLine("#EXT-X-INDEPENDENT-SEGMENTS");
+                    output.AppendLine("#EXT-X-DISCONTINUITY");
+
+                    started = true;
                 }
 
-                return new TrimPlaylistResult(nextPlaylistStart, startSequence, playlist, segments);
+                output.AppendLine(lines[i]);
+                string offset = currentTime.ToString("zzz").Replace(":", string.Empty);
+                output.AppendLine($"#EXT-X-PROGRAM-DATE-TIME:{currentTime:yyyy-MM-ddTHH:mm:ss.fff}{offset}");
+                output.AppendLine(lines[i + 2]);
+
+                currentTime += duration;
+                segments++;
+                i += 3;
             }
-            catch (Exception ex)
+
+            var playlist = output.ToString();
+            if (endWithDiscontinuity && !playlist.EndsWith($"#EXT-X-DISCONTINUITY{Environment.NewLine}"))
             {
-                try
-                {
-                    string file = _tempFilePool.GetNextTempFile(TempFileCategory.BadPlaylist);
-                    File.WriteAllLines(file, lines);
-
-                    _logger.LogError(ex, "Error filtering playlist. Bad playlist saved to {BadPlaylistFile}", file);
-                    
-                    // TODO: better error result?
-                    return new TrimPlaylistResult(playlistStart, 0, string.Empty, 0);
-                }
-                catch
-                {
-                    // do nothing
-                }
-
-                throw;
+                playlist += "#EXT-X-DISCONTINUITY" + Environment.NewLine;
             }
-        }
 
-        public TrimPlaylistResult TrimPlaylistWithDiscontinuity(
-            DateTimeOffset playlistStart,
-            DateTimeOffset filterBefore,
-            string[] lines)
+            return new TrimPlaylistResult(nextPlaylistStart, startSequence, playlist, segments);
+        }
+        catch (Exception ex)
         {
-            return TrimPlaylist(playlistStart, filterBefore, lines, int.MaxValue, true);
+            try
+            {
+                string file = _tempFilePool.GetNextTempFile(TempFileCategory.BadPlaylist);
+                File.WriteAllLines(file, lines);
+
+                _logger.LogError(ex, "Error filtering playlist. Bad playlist saved to {BadPlaylistFile}", file);
+                    
+                // TODO: better error result?
+                return new TrimPlaylistResult(playlistStart, 0, string.Empty, 0);
+            }
+            catch
+            {
+                // do nothing
+            }
+
+            throw;
         }
     }
 
-    public record TrimPlaylistResult(DateTimeOffset PlaylistStart, int Sequence, string Playlist, int SegmentCount);
+    public TrimPlaylistResult TrimPlaylistWithDiscontinuity(
+        DateTimeOffset playlistStart,
+        DateTimeOffset filterBefore,
+        string[] lines)
+    {
+        return TrimPlaylist(playlistStart, filterBefore, lines, int.MaxValue, true);
+    }
 }
+
+public record TrimPlaylistResult(DateTimeOffset PlaylistStart, int Sequence, string Playlist, int SegmentCount);
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/IFFmpegProcessServiceFactory.cs b/ErsatzTV.Core/FFmpeg/IFFmpegProcessServiceFactory.cs
index 7f754b52a..0994b185d 100644
--- a/ErsatzTV.Core/FFmpeg/IFFmpegProcessServiceFactory.cs
+++ b/ErsatzTV.Core/FFmpeg/IFFmpegProcessServiceFactory.cs
@@ -1,5 +1,4 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
 
 namespace ErsatzTV.Core.FFmpeg;
 
diff --git a/ErsatzTV.Core/FFmpeg/IHlsPlaylistFilter.cs b/ErsatzTV.Core/FFmpeg/IHlsPlaylistFilter.cs
index 10930c5e3..b498c72a2 100644
--- a/ErsatzTV.Core/FFmpeg/IHlsPlaylistFilter.cs
+++ b/ErsatzTV.Core/FFmpeg/IHlsPlaylistFilter.cs
@@ -1,6 +1,4 @@
-using System;
-
-namespace ErsatzTV.Core.FFmpeg;
+namespace ErsatzTV.Core.FFmpeg;
 
 public interface IHlsPlaylistFilter
 {
diff --git a/ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs b/ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs
index 182b3e2e5..86e88b317 100644
--- a/ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs
+++ b/ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs
@@ -1,266 +1,258 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.FFmpeg.Format;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class SongVideoGenerator : ISongVideoGenerator
 {
-    public class SongVideoGenerator : ISongVideoGenerator
-    {
-        private static readonly Random Random = new();
-        private static readonly object RandomLock = new();
+    private static readonly Random Random = new();
+    private static readonly object RandomLock = new();
         
-        private readonly ITempFilePool _tempFilePool;
-        private readonly IImageCache _imageCache;
-        private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+    private readonly ITempFilePool _tempFilePool;
+    private readonly IImageCache _imageCache;
+    private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
 
-        public SongVideoGenerator(
-            ITempFilePool tempFilePool,
-            IImageCache imageCache,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
+    public SongVideoGenerator(
+        ITempFilePool tempFilePool,
+        IImageCache imageCache,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory)
+    {
+        _tempFilePool = tempFilePool;
+        _imageCache = imageCache;
+        _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
+    }
+
+    public async Task<Tuple<string, MediaVersion>> GenerateSongVideo(
+        Song song,
+        Channel channel,
+        Option<ChannelWatermark> maybeGlobalWatermark,
+        string ffmpegPath)
+    {
+        Option<string> subtitleFile = None;
+
+        MediaVersion videoVersion = new FallbackMediaVersion
         {
-            _tempFilePool = tempFilePool;
-            _imageCache = imageCache;
-            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
-        }
-
-        public async Task<Tuple<string, MediaVersion>> GenerateSongVideo(
-            Song song,
-            Channel channel,
-            Option<ChannelWatermark> maybeGlobalWatermark,
-            string ffmpegPath)
+            Id = -1,
+            Chapters = new List<MediaChapter>(),
+            Width = 192,
+            Height = 108,
+            SampleAspectRatio = "1:1",
+            Streams = new List<MediaStream>
+            {
+                new() { MediaStreamKind = MediaStreamKind.Video, Index = 0, PixelFormat = "yuv420p" }
+            }
+        };
+            
+        string[] backgrounds =
         {
-            Option<string> subtitleFile = None;
+            "song_background_1.png",
+            "song_background_2.png",
+            "song_background_3.png"
+        };
 
-            MediaVersion videoVersion = new FallbackMediaVersion
-            {
-                Id = -1,
-                Chapters = new List<MediaChapter>(),
-                Width = 192,
-                Height = 108,
-                SampleAspectRatio = "1:1",
-                Streams = new List<MediaStream>
-                {
-                    new() { MediaStreamKind = MediaStreamKind.Video, Index = 0, PixelFormat = "yuv420p" }
-                }
-            };
+        // use random ETV color by default
+        string backgroundPath = Path.Combine(
+            FileSystemLayout.ResourcesCacheFolder,
+            backgrounds[NextRandom(backgrounds.Length)]);
+
+        Option<string> watermarkPath = None;
+
+        var boxBlur = false;
             
-            string[] backgrounds =
-            {
-                "song_background_1.png",
-                "song_background_2.png",
-                "song_background_3.png"
-            };
-
-            // use random ETV color by default
-            string backgroundPath = Path.Combine(
-                FileSystemLayout.ResourcesCacheFolder,
-                backgrounds[NextRandom(backgrounds.Length)]);
-
-            Option<string> watermarkPath = None;
-
-            var boxBlur = false;
+        const int HORIZONTAL_MARGIN_PERCENT = 3;
+        const int VERTICAL_MARGIN_PERCENT = 5;
+        const int WATERMARK_WIDTH_PERCENT = 25;
+        WatermarkLocation watermarkLocation = NextRandom(2) == 0
+            ? WatermarkLocation.BottomLeft
+            : WatermarkLocation.BottomRight;
             
-            const int HORIZONTAL_MARGIN_PERCENT = 3;
-            const int VERTICAL_MARGIN_PERCENT = 5;
-            const int WATERMARK_WIDTH_PERCENT = 25;
-            WatermarkLocation watermarkLocation = NextRandom(2) == 0
-                ? WatermarkLocation.BottomLeft
-                : WatermarkLocation.BottomRight;
-            
-            foreach (SongMetadata metadata in song.SongMetadata)
-            {
-                var fontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 20.0);
-                var largeFontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 10.0);
-                bool detailsStyle = NextRandom(2) == 0;
+        foreach (SongMetadata metadata in song.SongMetadata)
+        {
+            var fontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 20.0);
+            var largeFontSize = (int)Math.Round(channel.FFmpegProfile.Resolution.Height / 10.0);
+            bool detailsStyle = NextRandom(2) == 0;
                 
-                var sb = new StringBuilder();
+            var sb = new StringBuilder();
 
-                if (detailsStyle)
+            if (detailsStyle)
+            {
+                if (!string.IsNullOrWhiteSpace(metadata.Title))
                 {
-                    if (!string.IsNullOrWhiteSpace(metadata.Title))
-                    {
-                        sb.Append($"{{\\fs{largeFontSize}}}{metadata.Title}");
-                    }
+                    sb.Append($"{{\\fs{largeFontSize}}}{metadata.Title}");
+                }
                     
-                    if (!string.IsNullOrWhiteSpace(metadata.Artist))
-                    {
-                        sb.Append($"\\N{{\\fs{fontSize}}}{metadata.Artist}");
-                    }
-                }
-                else
+                if (!string.IsNullOrWhiteSpace(metadata.Artist))
                 {
-                    if (!string.IsNullOrWhiteSpace(metadata.Artist))
-                    {
-                        sb.Append(metadata.Artist);
-                    }
-
-                    if (!string.IsNullOrWhiteSpace(metadata.Title))
-                    {
-                        sb.Append($"\\N\"{metadata.Title}\"");
-                    }
-
-                    if (!string.IsNullOrWhiteSpace(metadata.Album))
-                    {
-                        sb.Append($"\\N{metadata.Album}");
-                    }
+                    sb.Append($"\\N{{\\fs{fontSize}}}{metadata.Artist}");
+                }
+            }
+            else
+            {
+                if (!string.IsNullOrWhiteSpace(metadata.Artist))
+                {
+                    sb.Append(metadata.Artist);
                 }
 
-                int leftMarginPercent = HORIZONTAL_MARGIN_PERCENT;
-                int rightMarginPercent = HORIZONTAL_MARGIN_PERCENT;
-
-                if (metadata.Artwork.Any(a => a.ArtworkKind == ArtworkKind.Thumbnail))
+                if (!string.IsNullOrWhiteSpace(metadata.Title))
                 {
-                    switch (watermarkLocation)
-                    {
-                        case WatermarkLocation.BottomLeft:
-                            leftMarginPercent += WATERMARK_WIDTH_PERCENT + HORIZONTAL_MARGIN_PERCENT;
-                            break;
-                        case WatermarkLocation.BottomRight:
-                            leftMarginPercent = rightMarginPercent = HORIZONTAL_MARGIN_PERCENT;
-                            rightMarginPercent += WATERMARK_WIDTH_PERCENT + HORIZONTAL_MARGIN_PERCENT;
-                            break;
-                    }
+                    sb.Append($"\\N\"{metadata.Title}\"");
                 }
 
-                var leftMargin = (int)Math.Round(leftMarginPercent / 100.0 * channel.FFmpegProfile.Resolution.Width);
-                var rightMargin = (int)Math.Round(rightMarginPercent / 100.0 * channel.FFmpegProfile.Resolution.Width);
-                var verticalMargin = (int)Math.Round(VERTICAL_MARGIN_PERCENT / 100.0 * channel.FFmpegProfile.Resolution.Height);
-
-                subtitleFile = await new SubtitleBuilder(_tempFilePool)
-                    .WithResolution(channel.FFmpegProfile.Resolution)
-                    .WithFontName("OPTIKabel-Heavy")
-                    .WithFontSize(fontSize)
-                    .WithPrimaryColor("&HFFFFFF")
-                    .WithOutlineColor("&H444444")
-                    .WithAlignment(0)
-                    .WithMarginRight(rightMargin)
-                    .WithMarginLeft(leftMargin)
-                    .WithMarginV(verticalMargin)
-                    .WithBorderStyle(1)
-                    .WithShadow(3)
-                    .WithFormattedContent(sb.ToString())
-                    .BuildFile();
-                
-                // use thumbnail (cover art) if present
-                foreach (Artwork artwork in Optional(
-                    metadata.Artwork.Find(a => a.ArtworkKind == ArtworkKind.Thumbnail)))
+                if (!string.IsNullOrWhiteSpace(metadata.Album))
                 {
-                    // signal that we want to use cover art as watermark
-                    videoVersion = new CoverArtMediaVersion
-                    {
-                        Chapters = new List<MediaChapter>(),
-                        // always stretch cover art
-                        Width = 192,
-                        Height = 108,
-                        SampleAspectRatio = "1:1",
-                        Streams = new List<MediaStream>
-                        {
-                            new() { MediaStreamKind = MediaStreamKind.Video, Index = 0 }
-                        }
-                    };
-
-                    string customPath = _imageCache.GetPathForImage(
-                        artwork.Path,
-                        ArtworkKind.Thumbnail,
-                        Option<int>.None);
-                    
-                    watermarkPath = customPath;
-
-                    // randomize selected blur hash
-                    var hashes = new List<string>
-                    {
-                        artwork.BlurHash43,
-                        artwork.BlurHash54,
-                        artwork.BlurHash64
-                    }.Filter(s => !string.IsNullOrWhiteSpace(s)).ToList();
-
-                    if (hashes.Any())
-                    {
-                        string hash = hashes[NextRandom(hashes.Count)];
-                        
-                        backgroundPath = await _imageCache.WriteBlurHash(
-                            hash,
-                            channel.FFmpegProfile.Resolution);
-
-                        videoVersion.Height = channel.FFmpegProfile.Resolution.Height;
-                        videoVersion.Width = channel.FFmpegProfile.Resolution.Width;
-                    }
-                    else
-                    {
-                        backgroundPath = customPath;
-                        boxBlur = true;
-                    }
+                    sb.Append($"\\N{metadata.Album}");
                 }
             }
 
-            string videoPath = backgroundPath;
+            int leftMarginPercent = HORIZONTAL_MARGIN_PERCENT;
+            int rightMarginPercent = HORIZONTAL_MARGIN_PERCENT;
 
-            videoVersion.MediaFiles = new List<MediaFile>
+            if (metadata.Artwork.Any(a => a.ArtworkKind == ArtworkKind.Thumbnail))
             {
-                new() { Path = videoPath }
-            };
+                switch (watermarkLocation)
+                {
+                    case WatermarkLocation.BottomLeft:
+                        leftMarginPercent += WATERMARK_WIDTH_PERCENT + HORIZONTAL_MARGIN_PERCENT;
+                        break;
+                    case WatermarkLocation.BottomRight:
+                        leftMarginPercent = rightMarginPercent = HORIZONTAL_MARGIN_PERCENT;
+                        rightMarginPercent += WATERMARK_WIDTH_PERCENT + HORIZONTAL_MARGIN_PERCENT;
+                        break;
+                }
+            }
 
-            IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
-            Either<BaseError, string> maybeSongImage = await ffmpegProcessService.GenerateSongImage(
-                ffmpegPath,
-                subtitleFile,
-                channel,
-                maybeGlobalWatermark,
-                videoVersion,
-                videoPath,
-                boxBlur,
-                watermarkPath,
-                watermarkLocation,
-                HORIZONTAL_MARGIN_PERCENT,
-                VERTICAL_MARGIN_PERCENT,
-                WATERMARK_WIDTH_PERCENT);
+            var leftMargin = (int)Math.Round(leftMarginPercent / 100.0 * channel.FFmpegProfile.Resolution.Width);
+            var rightMargin = (int)Math.Round(rightMarginPercent / 100.0 * channel.FFmpegProfile.Resolution.Width);
+            var verticalMargin = (int)Math.Round(VERTICAL_MARGIN_PERCENT / 100.0 * channel.FFmpegProfile.Resolution.Height);
 
-            foreach (string si in maybeSongImage.RightToSeq())
+            subtitleFile = await new SubtitleBuilder(_tempFilePool)
+                .WithResolution(channel.FFmpegProfile.Resolution)
+                .WithFontName("OPTIKabel-Heavy")
+                .WithFontSize(fontSize)
+                .WithPrimaryColor("&HFFFFFF")
+                .WithOutlineColor("&H444444")
+                .WithAlignment(0)
+                .WithMarginRight(rightMargin)
+                .WithMarginLeft(leftMargin)
+                .WithMarginV(verticalMargin)
+                .WithBorderStyle(1)
+                .WithShadow(3)
+                .WithFormattedContent(sb.ToString())
+                .BuildFile();
+                
+            // use thumbnail (cover art) if present
+            foreach (Artwork artwork in Optional(
+                         metadata.Artwork.Find(a => a.ArtworkKind == ArtworkKind.Thumbnail)))
             {
-                videoPath = si;
-                videoVersion = new BackgroundImageMediaVersion
+                // signal that we want to use cover art as watermark
+                videoVersion = new CoverArtMediaVersion
                 {
                     Chapters = new List<MediaChapter>(),
-                    // song image has been pre-generated with correct size
-                    Height = channel.FFmpegProfile.Resolution.Height,
-                    Width = channel.FFmpegProfile.Resolution.Width,
+                    // always stretch cover art
+                    Width = 192,
+                    Height = 108,
                     SampleAspectRatio = "1:1",
                     Streams = new List<MediaStream>
                     {
-                        new()
-                        {
-                            MediaStreamKind = MediaStreamKind.Video,
-                            Index = 0,
-                            Codec = VideoFormat.GeneratedImage,
-                            PixelFormat = new PixelFormatUnknown().Name // the resulting pixel format is unknown
-                        },
-                    },
-                    MediaFiles = new List<MediaFile>
-                    {
-                        new() { Path = si }
+                        new() { MediaStreamKind = MediaStreamKind.Video, Index = 0 }
                     }
                 };
-            }
 
-            return Tuple(videoPath, videoVersion);
-        }
-        
-        private static int NextRandom(int max)
-        {
-            lock (RandomLock)
-            {
-                return Random.Next() % max;
+                string customPath = _imageCache.GetPathForImage(
+                    artwork.Path,
+                    ArtworkKind.Thumbnail,
+                    Option<int>.None);
+                    
+                watermarkPath = customPath;
+
+                // randomize selected blur hash
+                var hashes = new List<string>
+                {
+                    artwork.BlurHash43,
+                    artwork.BlurHash54,
+                    artwork.BlurHash64
+                }.Filter(s => !string.IsNullOrWhiteSpace(s)).ToList();
+
+                if (hashes.Any())
+                {
+                    string hash = hashes[NextRandom(hashes.Count)];
+                        
+                    backgroundPath = await _imageCache.WriteBlurHash(
+                        hash,
+                        channel.FFmpegProfile.Resolution);
+
+                    videoVersion.Height = channel.FFmpegProfile.Resolution.Height;
+                    videoVersion.Width = channel.FFmpegProfile.Resolution.Width;
+                }
+                else
+                {
+                    backgroundPath = customPath;
+                    boxBlur = true;
+                }
             }
         }
+
+        string videoPath = backgroundPath;
+
+        videoVersion.MediaFiles = new List<MediaFile>
+        {
+            new() { Path = videoPath }
+        };
+
+        IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
+        Either<BaseError, string> maybeSongImage = await ffmpegProcessService.GenerateSongImage(
+            ffmpegPath,
+            subtitleFile,
+            channel,
+            maybeGlobalWatermark,
+            videoVersion,
+            videoPath,
+            boxBlur,
+            watermarkPath,
+            watermarkLocation,
+            HORIZONTAL_MARGIN_PERCENT,
+            VERTICAL_MARGIN_PERCENT,
+            WATERMARK_WIDTH_PERCENT);
+
+        foreach (string si in maybeSongImage.RightToSeq())
+        {
+            videoPath = si;
+            videoVersion = new BackgroundImageMediaVersion
+            {
+                Chapters = new List<MediaChapter>(),
+                // song image has been pre-generated with correct size
+                Height = channel.FFmpegProfile.Resolution.Height,
+                Width = channel.FFmpegProfile.Resolution.Width,
+                SampleAspectRatio = "1:1",
+                Streams = new List<MediaStream>
+                {
+                    new()
+                    {
+                        MediaStreamKind = MediaStreamKind.Video,
+                        Index = 0,
+                        Codec = VideoFormat.GeneratedImage,
+                        PixelFormat = new PixelFormatUnknown().Name // the resulting pixel format is unknown
+                    },
+                },
+                MediaFiles = new List<MediaFile>
+                {
+                    new() { Path = si }
+                }
+            };
+        }
+
+        return Tuple(videoPath, videoVersion);
+    }
+        
+    private static int NextRandom(int max)
+    {
+        lock (RandomLock)
+        {
+            return Random.Next() % max;
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/SubtitleBuilder.cs b/ErsatzTV.Core/FFmpeg/SubtitleBuilder.cs
index d67a7f4ed..fc573001d 100644
--- a/ErsatzTV.Core/FFmpeg/SubtitleBuilder.cs
+++ b/ErsatzTV.Core/FFmpeg/SubtitleBuilder.cs
@@ -1,138 +1,133 @@
-using System.IO;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.Interfaces.FFmpeg;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class SubtitleBuilder
 {
-    public class SubtitleBuilder
+    private readonly ITempFilePool _tempFilePool;
+    private string _content;
+    private Option<IDisplaySize> _resolution = None;
+    private Option<string> _fontName;
+    private Option<int> _fontSize;
+    private Option<string> _primaryColor;
+    private Option<string> _outlineColor;
+    private Option<int> _alignment;
+    private int _marginRight;
+    private int _marginLeft;
+    private int _marginV;
+    private Option<int> _borderStyle;
+    private Option<int> _shadow;
+
+    public SubtitleBuilder(ITempFilePool tempFilePool)
     {
-        private readonly ITempFilePool _tempFilePool;
-        private string _content;
-        private Option<IDisplaySize> _resolution = None;
-        private Option<string> _fontName;
-        private Option<int> _fontSize;
-        private Option<string> _primaryColor;
-        private Option<string> _outlineColor;
-        private Option<int> _alignment;
-        private int _marginRight;
-        private int _marginLeft;
-        private int _marginV;
-        private Option<int> _borderStyle;
-        private Option<int> _shadow;
-
-        public SubtitleBuilder(ITempFilePool tempFilePool)
-        {
-            _tempFilePool = tempFilePool;
-        }
-
-        public SubtitleBuilder WithResolution(IDisplaySize resolution)
-        {
-            _resolution = Some(resolution);
-            return this;
-        }
-
-        public SubtitleBuilder WithFontName(string fontName)
-        {
-            _fontName = fontName;
-            return this;
-        }
-
-        public SubtitleBuilder WithFontSize(int fontSize)
-        {
-            _fontSize = fontSize;
-            return this;
-        }
-
-        public SubtitleBuilder WithPrimaryColor(string primaryColor)
-        {
-            _primaryColor = primaryColor;
-            return this;
-        }
-
-        public SubtitleBuilder WithOutlineColor(string outlineColor)
-        {
-            _outlineColor = outlineColor;
-            return this;
-        }
-
-        public SubtitleBuilder WithAlignment(int alignment)
-        {
-            _alignment = alignment;
-            return this;
-        }
-
-        public SubtitleBuilder WithMarginRight(int marginRight)
-        {
-            _marginRight = marginRight;
-            return this;
-        }
-
-        public SubtitleBuilder WithMarginLeft(int marginLeft)
-        {
-            _marginLeft = marginLeft;
-            return this;
-        }
-        
-        public SubtitleBuilder WithMarginV(int marginV)
-        {
-            _marginV = marginV;
-            return this;
-        }
-
-        public SubtitleBuilder WithBorderStyle(int borderStyle)
-        {
-            _borderStyle = borderStyle;
-            return this;
-        }
-
-        public SubtitleBuilder WithShadow(int shadow)
-        {
-            _shadow = shadow;
-            return this;
-        }
-
-        public SubtitleBuilder WithFormattedContent(string content)
-        {
-            _content = content;
-            return this;
-        }
-        
-        public async Task<string> BuildFile()
-        {
-            string fileName = _tempFilePool.GetNextTempFile(TempFileCategory.Subtitle);
-
-            var sb = new StringBuilder();
-            sb.AppendLine("[Script Info]");
-            sb.AppendLine("ScriptType: v4.00+");
-            sb.AppendLine("WrapStyle: 0");
-            sb.AppendLine("ScaledBorderAndShadow: yes");
-            sb.AppendLine("YCbCr Matrix: None");
-
-            foreach (IDisplaySize resolution in _resolution)
-            {
-                sb.AppendLine($"PlayResX: {resolution.Width}");
-                sb.AppendLine($"PlayResY: {resolution.Height}");
-            }
-
-            sb.AppendLine("[V4+ Styles]");
-            sb.AppendLine("Format: Name, Fontname, Fontsize, PrimaryColour, OutlineColour, BorderStyle, Outline, Shadow, Alignment, Encoding");
-            sb.AppendLine($"Style: Default,{await _fontName.IfNoneAsync("")},{await _fontSize.IfNoneAsync(32)},{await _primaryColor.IfNoneAsync("")},{await _outlineColor.IfNoneAsync("")},{await _borderStyle.IfNoneAsync(0)},1,{await _shadow.IfNoneAsync(0)},{await _alignment.IfNoneAsync(0)},1");
-
-            sb.AppendLine("[Events]");
-            sb.AppendLine("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text");
-            sb.AppendLine($"Dialogue: 0,0:00:00.00,99:99:99.99,Default,,{_marginLeft},{_marginRight},{_marginV},,{_content}");
-
-            if (!string.IsNullOrWhiteSpace(_content))
-            {
-                sb.AppendLine(_content);
-            }
-
-            await File.WriteAllTextAsync(fileName, sb.ToString());
-
-            return fileName;
-        }
+        _tempFilePool = tempFilePool;
     }
-}
+
+    public SubtitleBuilder WithResolution(IDisplaySize resolution)
+    {
+        _resolution = Some(resolution);
+        return this;
+    }
+
+    public SubtitleBuilder WithFontName(string fontName)
+    {
+        _fontName = fontName;
+        return this;
+    }
+
+    public SubtitleBuilder WithFontSize(int fontSize)
+    {
+        _fontSize = fontSize;
+        return this;
+    }
+
+    public SubtitleBuilder WithPrimaryColor(string primaryColor)
+    {
+        _primaryColor = primaryColor;
+        return this;
+    }
+
+    public SubtitleBuilder WithOutlineColor(string outlineColor)
+    {
+        _outlineColor = outlineColor;
+        return this;
+    }
+
+    public SubtitleBuilder WithAlignment(int alignment)
+    {
+        _alignment = alignment;
+        return this;
+    }
+
+    public SubtitleBuilder WithMarginRight(int marginRight)
+    {
+        _marginRight = marginRight;
+        return this;
+    }
+
+    public SubtitleBuilder WithMarginLeft(int marginLeft)
+    {
+        _marginLeft = marginLeft;
+        return this;
+    }
+        
+    public SubtitleBuilder WithMarginV(int marginV)
+    {
+        _marginV = marginV;
+        return this;
+    }
+
+    public SubtitleBuilder WithBorderStyle(int borderStyle)
+    {
+        _borderStyle = borderStyle;
+        return this;
+    }
+
+    public SubtitleBuilder WithShadow(int shadow)
+    {
+        _shadow = shadow;
+        return this;
+    }
+
+    public SubtitleBuilder WithFormattedContent(string content)
+    {
+        _content = content;
+        return this;
+    }
+        
+    public async Task<string> BuildFile()
+    {
+        string fileName = _tempFilePool.GetNextTempFile(TempFileCategory.Subtitle);
+
+        var sb = new StringBuilder();
+        sb.AppendLine("[Script Info]");
+        sb.AppendLine("ScriptType: v4.00+");
+        sb.AppendLine("WrapStyle: 0");
+        sb.AppendLine("ScaledBorderAndShadow: yes");
+        sb.AppendLine("YCbCr Matrix: None");
+
+        foreach (IDisplaySize resolution in _resolution)
+        {
+            sb.AppendLine($"PlayResX: {resolution.Width}");
+            sb.AppendLine($"PlayResY: {resolution.Height}");
+        }
+
+        sb.AppendLine("[V4+ Styles]");
+        sb.AppendLine("Format: Name, Fontname, Fontsize, PrimaryColour, OutlineColour, BorderStyle, Outline, Shadow, Alignment, Encoding");
+        sb.AppendLine($"Style: Default,{await _fontName.IfNoneAsync("")},{await _fontSize.IfNoneAsync(32)},{await _primaryColor.IfNoneAsync("")},{await _outlineColor.IfNoneAsync("")},{await _borderStyle.IfNoneAsync(0)},1,{await _shadow.IfNoneAsync(0)},{await _alignment.IfNoneAsync(0)},1");
+
+        sb.AppendLine("[Events]");
+        sb.AppendLine("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text");
+        sb.AppendLine($"Dialogue: 0,0:00:00.00,99:99:99.99,Default,,{_marginLeft},{_marginRight},{_marginV},,{_content}");
+
+        if (!string.IsNullOrWhiteSpace(_content))
+        {
+            sb.AppendLine(_content);
+        }
+
+        await File.WriteAllTextAsync(fileName, sb.ToString());
+
+        return fileName;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/TempFileCategory.cs b/ErsatzTV.Core/FFmpeg/TempFileCategory.cs
index 24a581109..33d60573b 100644
--- a/ErsatzTV.Core/FFmpeg/TempFileCategory.cs
+++ b/ErsatzTV.Core/FFmpeg/TempFileCategory.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.FFmpeg
-{
-    public enum TempFileCategory
-    {
-        Subtitle = 0,
-        SongBackground = 1,
-        CoverArt = 2,
-        CachedArtwork = 3,
+namespace ErsatzTV.Core.FFmpeg;
 
-        BadPlaylist = 99
-    }
-}
+public enum TempFileCategory
+{
+    Subtitle = 0,
+    SongBackground = 1,
+    CoverArt = 2,
+    CachedArtwork = 3,
+
+    BadPlaylist = 99
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/TempFilePool.cs b/ErsatzTV.Core/FFmpeg/TempFilePool.cs
index 10e1bdf67..77511f733 100644
--- a/ErsatzTV.Core/FFmpeg/TempFilePool.cs
+++ b/ErsatzTV.Core/FFmpeg/TempFilePool.cs
@@ -1,35 +1,32 @@
-using System.Collections.Generic;
-using System.IO;
-using ErsatzTV.Core.Interfaces.FFmpeg;
+using ErsatzTV.Core.Interfaces.FFmpeg;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+public class TempFilePool : ITempFilePool
 {
-    public class TempFilePool : ITempFilePool
+    private const int ItemLimit = 10;
+    private readonly Dictionary<TempFileCategory, int> _state = new();
+    private readonly object _lock = new();
+
+    public string GetNextTempFile(TempFileCategory category)
     {
-        private const int ItemLimit = 10;
-        private readonly Dictionary<TempFileCategory, int> _state = new();
-        private readonly object _lock = new();
-
-        public string GetNextTempFile(TempFileCategory category)
+        lock (_lock)
         {
-            lock (_lock)
+            var index = 0;
+
+            if (_state.TryGetValue(category, out int current))
             {
-                var index = 0;
-
-                if (_state.TryGetValue(category, out int current))
-                {
-                    index = (current + 1) % ItemLimit;
-                }
-
-                _state[category] = index;
-
-                return GetFileName(category, index);
+                index = (current + 1) % ItemLimit;
             }
-        }
 
-        private static string GetFileName(TempFileCategory category, int index)
-        {
-            return Path.Combine(FileSystemLayout.TempFilePoolFolder, $"{category}_{index}".ToLowerInvariant());
+            _state[category] = index;
+
+            return GetFileName(category, index);
         }
     }
-}
+
+    private static string GetFileName(TempFileCategory category, int index)
+    {
+        return Path.Combine(FileSystemLayout.TempFilePoolFolder, $"{category}_{index}".ToLowerInvariant());
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/VaapiDriver.cs b/ErsatzTV.Core/FFmpeg/VaapiDriver.cs
index 2721976d1..177314b90 100644
--- a/ErsatzTV.Core/FFmpeg/VaapiDriver.cs
+++ b/ErsatzTV.Core/FFmpeg/VaapiDriver.cs
@@ -1,13 +1,12 @@
 using System.Diagnostics.CodeAnalysis;
 
-namespace ErsatzTV.Core.FFmpeg
+namespace ErsatzTV.Core.FFmpeg;
+
+[SuppressMessage("ReSharper", "InconsistentNaming")]
+public enum VaapiDriver
 {
-    [SuppressMessage("ReSharper", "InconsistentNaming")]
-    public enum VaapiDriver
-    {
-        Default = 0,
-        iHD = 1,
-        i965 = 2,
-        RadeonSI = 3
-    }
-}
+    Default = 0,
+    iHD = 1,
+    i965 = 2,
+    RadeonSI = 3
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/FFmpeg/WatermarkCalculator.cs b/ErsatzTV.Core/FFmpeg/WatermarkCalculator.cs
index 4abf02e55..74e20967d 100644
--- a/ErsatzTV.Core/FFmpeg/WatermarkCalculator.cs
+++ b/ErsatzTV.Core/FFmpeg/WatermarkCalculator.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using LanguageExt;
-
-namespace ErsatzTV.Core.FFmpeg;
+namespace ErsatzTV.Core.FFmpeg;
 
 public static class WatermarkCalculator
 {
diff --git a/ErsatzTV.Core/FFmpeg/WatermarkOptions.cs b/ErsatzTV.Core/FFmpeg/WatermarkOptions.cs
index 43ddfe2b8..9aaded48b 100644
--- a/ErsatzTV.Core/FFmpeg/WatermarkOptions.cs
+++ b/ErsatzTV.Core/FFmpeg/WatermarkOptions.cs
@@ -1,11 +1,9 @@
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 
-namespace ErsatzTV.Core.FFmpeg
-{
-    public record WatermarkOptions(
-        Option<ChannelWatermark> Watermark,
-        Option<string> ImagePath,
-        Option<int> ImageStreamIndex,
-        bool IsAnimated);
-}
+namespace ErsatzTV.Core.FFmpeg;
+
+public record WatermarkOptions(
+    Option<ChannelWatermark> Watermark,
+    Option<string> ImagePath,
+    Option<int> ImageStreamIndex,
+    bool IsAnimated);
\ No newline at end of file
diff --git a/ErsatzTV.Core/FileSystemLayout.cs b/ErsatzTV.Core/FileSystemLayout.cs
index 96b7ca67a..f36c006cb 100644
--- a/ErsatzTV.Core/FileSystemLayout.cs
+++ b/ErsatzTV.Core/FileSystemLayout.cs
@@ -1,47 +1,43 @@
-using System;
-using System.IO;
+namespace ErsatzTV.Core;
 
-namespace ErsatzTV.Core
+public static class FileSystemLayout
 {
-    public static class FileSystemLayout
-    {
-        public static readonly string AppDataFolder = Path.Combine(
-            Environment.GetFolderPath(
-                Environment.SpecialFolder.LocalApplicationData,
-                Environment.SpecialFolderOption.Create),
-            "ersatztv");
+    public static readonly string AppDataFolder = Path.Combine(
+        Environment.GetFolderPath(
+            Environment.SpecialFolder.LocalApplicationData,
+            Environment.SpecialFolderOption.Create),
+        "ersatztv");
 
-        // TODO: find a different spot for this; configurable?
-        public static readonly string TranscodeFolder = Path.Combine(
-            Environment.GetFolderPath(
-                Environment.SpecialFolder.LocalApplicationData,
-                Environment.SpecialFolderOption.Create),
-            "etv-transcode");
+    // TODO: find a different spot for this; configurable?
+    public static readonly string TranscodeFolder = Path.Combine(
+        Environment.GetFolderPath(
+            Environment.SpecialFolder.LocalApplicationData,
+            Environment.SpecialFolderOption.Create),
+        "etv-transcode");
 
-        public static readonly string LogsFolder = Path.Combine(AppDataFolder, "logs");
+    public static readonly string LogsFolder = Path.Combine(AppDataFolder, "logs");
 
-        public static readonly string DatabasePath = Path.Combine(AppDataFolder, "ersatztv.sqlite3");
+    public static readonly string DatabasePath = Path.Combine(AppDataFolder, "ersatztv.sqlite3");
 
-        public static readonly string LogDatabasePath = Path.Combine(AppDataFolder, "logs.sqlite3");
-        public static readonly string LogFilePath = Path.Combine(LogsFolder, "ersatztv.log");
+    public static readonly string LogDatabasePath = Path.Combine(AppDataFolder, "logs.sqlite3");
+    public static readonly string LogFilePath = Path.Combine(LogsFolder, "ersatztv.log");
 
-        public static readonly string LegacyImageCacheFolder = Path.Combine(AppDataFolder, "cache", "images");
-        public static readonly string ResourcesCacheFolder = Path.Combine(AppDataFolder, "cache", "resources");
+    public static readonly string LegacyImageCacheFolder = Path.Combine(AppDataFolder, "cache", "images");
+    public static readonly string ResourcesCacheFolder = Path.Combine(AppDataFolder, "cache", "resources");
 
-        public static readonly string PlexSecretsPath = Path.Combine(AppDataFolder, "plex-secrets.json");
-        public static readonly string JellyfinSecretsPath = Path.Combine(AppDataFolder, "jellyfin-secrets.json");
-        public static readonly string EmbySecretsPath = Path.Combine(AppDataFolder, "emby-secrets.json");
+    public static readonly string PlexSecretsPath = Path.Combine(AppDataFolder, "plex-secrets.json");
+    public static readonly string JellyfinSecretsPath = Path.Combine(AppDataFolder, "jellyfin-secrets.json");
+    public static readonly string EmbySecretsPath = Path.Combine(AppDataFolder, "emby-secrets.json");
 
-        public static readonly string FFmpegReportsFolder = Path.Combine(AppDataFolder, "ffmpeg-reports");
-        public static readonly string SearchIndexFolder = Path.Combine(AppDataFolder, "search-index");
-        public static readonly string TempFilePoolFolder = Path.Combine(AppDataFolder, "temp-pool");
+    public static readonly string FFmpegReportsFolder = Path.Combine(AppDataFolder, "ffmpeg-reports");
+    public static readonly string SearchIndexFolder = Path.Combine(AppDataFolder, "search-index");
+    public static readonly string TempFilePoolFolder = Path.Combine(AppDataFolder, "temp-pool");
 
-        public static readonly string ArtworkCacheFolder = Path.Combine(AppDataFolder, "cache", "artwork");
+    public static readonly string ArtworkCacheFolder = Path.Combine(AppDataFolder, "cache", "artwork");
 
-        public static readonly string PosterCacheFolder = Path.Combine(ArtworkCacheFolder, "posters");
-        public static readonly string ThumbnailCacheFolder = Path.Combine(ArtworkCacheFolder, "thumbnails");
-        public static readonly string LogoCacheFolder = Path.Combine(ArtworkCacheFolder, "logos");
-        public static readonly string FanArtCacheFolder = Path.Combine(ArtworkCacheFolder, "fanart");
-        public static readonly string WatermarkCacheFolder = Path.Combine(ArtworkCacheFolder, "watermarks");
-    }
-}
+    public static readonly string PosterCacheFolder = Path.Combine(ArtworkCacheFolder, "posters");
+    public static readonly string ThumbnailCacheFolder = Path.Combine(ArtworkCacheFolder, "thumbnails");
+    public static readonly string LogoCacheFolder = Path.Combine(ArtworkCacheFolder, "logos");
+    public static readonly string FanArtCacheFolder = Path.Combine(ArtworkCacheFolder, "fanart");
+    public static readonly string WatermarkCacheFolder = Path.Combine(ArtworkCacheFolder, "watermarks");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/GlobalUsings.cs b/ErsatzTV.Core/GlobalUsings.cs
new file mode 100644
index 000000000..9d0867420
--- /dev/null
+++ b/ErsatzTV.Core/GlobalUsings.cs
@@ -0,0 +1,4 @@
+global using LanguageExt;
+global using static LanguageExt.Prelude;
+global using Unit = LanguageExt.Unit;
+global using Array = System.Array;
\ No newline at end of file
diff --git a/ErsatzTV.Core/Hdhr/DeviceXml.cs b/ErsatzTV.Core/Hdhr/DeviceXml.cs
index a8a5fae9b..82c7d55e7 100644
--- a/ErsatzTV.Core/Hdhr/DeviceXml.cs
+++ b/ErsatzTV.Core/Hdhr/DeviceXml.cs
@@ -1,9 +1,9 @@
-namespace ErsatzTV.Core.Hdhr
+namespace ErsatzTV.Core.Hdhr;
+
+public record DeviceXml(string Scheme, string Host)
 {
-    public record DeviceXml(string Scheme, string Host)
-    {
-        public string ToXml() =>
-            @$"<root xmlns=""urn:schemas-upnp-org:device-1-0"">
+    public string ToXml() =>
+        @$"<root xmlns=""urn:schemas-upnp-org:device-1-0"">
     <URLBase>{Scheme}://{Host}</URLBase>
     <specVersion>
         <major>1</major>
@@ -19,5 +19,4 @@
         <UDN>uuid:2020-03-S3LA-BG3LIA:2</UDN>
     </device>
 </root>";
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Hdhr/Discover.cs b/ErsatzTV.Core/Hdhr/Discover.cs
index ba47a55f0..934bfc6dc 100644
--- a/ErsatzTV.Core/Hdhr/Discover.cs
+++ b/ErsatzTV.Core/Hdhr/Discover.cs
@@ -1,29 +1,28 @@
 using System.Diagnostics.CodeAnalysis;
 
-namespace ErsatzTV.Core.Hdhr
+namespace ErsatzTV.Core.Hdhr;
+
+[SuppressMessage("ReSharper", "InconsistentNaming")]
+public class Discover
 {
-    [SuppressMessage("ReSharper", "InconsistentNaming")]
-    public class Discover
+    private readonly string _host;
+    private readonly string _scheme;
+
+    public Discover(string scheme, string host, int tunerCount)
     {
-        private readonly string _host;
-        private readonly string _scheme;
-
-        public Discover(string scheme, string host, int tunerCount)
-        {
-            _scheme = scheme;
-            _host = host;
-            TunerCount = tunerCount;
-        }
-
-        public string DeviceAuth => "";
-        public string DeviceID => "ErsatzTV";
-        public string FirmwareName => "hdhomeruntc_atsc";
-        public string FirmwareVersion => "20190621";
-        public string FriendlyName => "ErsatzTV";
-        public string LineupURL => $"{_scheme}://{_host}/lineup.json";
-        public string Manufacturer => "ErsatzTV - Silicondust";
-        public string ManufacturerURL => "https://github.com/jasongdove/ErsatzTV";
-        public string ModelNumber => "HDTC-2US";
-        public int TunerCount { get; }
+        _scheme = scheme;
+        _host = host;
+        TunerCount = tunerCount;
     }
-}
+
+    public string DeviceAuth => "";
+    public string DeviceID => "ErsatzTV";
+    public string FirmwareName => "hdhomeruntc_atsc";
+    public string FirmwareVersion => "20190621";
+    public string FriendlyName => "ErsatzTV";
+    public string LineupURL => $"{_scheme}://{_host}/lineup.json";
+    public string Manufacturer => "ErsatzTV - Silicondust";
+    public string ManufacturerURL => "https://github.com/jasongdove/ErsatzTV";
+    public string ModelNumber => "HDTC-2US";
+    public int TunerCount { get; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Hdhr/LineupItem.cs b/ErsatzTV.Core/Hdhr/LineupItem.cs
index 2db23dcfe..c5815fffc 100644
--- a/ErsatzTV.Core/Hdhr/LineupItem.cs
+++ b/ErsatzTV.Core/Hdhr/LineupItem.cs
@@ -1,29 +1,28 @@
 using System.Diagnostics.CodeAnalysis;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Hdhr
+namespace ErsatzTV.Core.Hdhr;
+
+[SuppressMessage("ReSharper", "InconsistentNaming")]
+public class LineupItem
 {
-    [SuppressMessage("ReSharper", "InconsistentNaming")]
-    public class LineupItem
+    private readonly Channel _channel;
+    private readonly string _host;
+    private readonly string _scheme;
+
+    public LineupItem(string scheme, string host, Channel channel)
     {
-        private readonly Channel _channel;
-        private readonly string _host;
-        private readonly string _scheme;
-
-        public LineupItem(string scheme, string host, Channel channel)
-        {
-            _scheme = scheme;
-            _host = host;
-            _channel = channel;
-        }
-
-        public string GuideNumber => _channel.Number;
-        public string GuideName => _channel.Name;
-
-        public string URL => _channel.StreamingMode switch
-        {
-            StreamingMode.TransportStream => $"{_scheme}://{_host}/iptv/channel/{_channel.Number}.ts?mode=ts-legacy",
-            _ => $"{_scheme}://{_host}/iptv/channel/{_channel.Number}.ts"
-        };
+        _scheme = scheme;
+        _host = host;
+        _channel = channel;
     }
-}
+
+    public string GuideNumber => _channel.Number;
+    public string GuideName => _channel.Name;
+
+    public string URL => _channel.StreamingMode switch
+    {
+        StreamingMode.TransportStream => $"{_scheme}://{_host}/iptv/channel/{_channel.Number}.ts?mode=ts-legacy",
+        _ => $"{_scheme}://{_host}/iptv/channel/{_channel.Number}.ts"
+    };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Hdhr/LineupStatus.cs b/ErsatzTV.Core/Hdhr/LineupStatus.cs
index 1469f5a70..a417c81b1 100644
--- a/ErsatzTV.Core/Hdhr/LineupStatus.cs
+++ b/ErsatzTV.Core/Hdhr/LineupStatus.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Hdhr;
 
-namespace ErsatzTV.Core.Hdhr
+public class LineupStatus
 {
-    public class LineupStatus
-    {
-        public int ScanInProgress = 0;
-        public int ScanPossible = 1;
-        public string Source = "Cable";
-        public IEnumerable<string> SourceList = new[] { "Cable" };
-    }
-}
+    public int ScanInProgress = 0;
+    public int ScanPossible = 1;
+    public string Source = "Cable";
+    public IEnumerable<string> SourceList = new[] { "Cable" };
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/Checks/IEpisodeMetadataHealthCheck.cs b/ErsatzTV.Core/Health/Checks/IEpisodeMetadataHealthCheck.cs
index 25a9e2d38..23e9ec62e 100644
--- a/ErsatzTV.Core/Health/Checks/IEpisodeMetadataHealthCheck.cs
+++ b/ErsatzTV.Core/Health/Checks/IEpisodeMetadataHealthCheck.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Health.Checks
+namespace ErsatzTV.Core.Health.Checks;
+
+public interface IEpisodeMetadataHealthCheck : IHealthCheck
 {
-    public interface IEpisodeMetadataHealthCheck : IHealthCheck
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/Checks/IFFmpegReportsHealthCheck.cs b/ErsatzTV.Core/Health/Checks/IFFmpegReportsHealthCheck.cs
index 1edaf3d9e..62261d69a 100644
--- a/ErsatzTV.Core/Health/Checks/IFFmpegReportsHealthCheck.cs
+++ b/ErsatzTV.Core/Health/Checks/IFFmpegReportsHealthCheck.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Health.Checks
+namespace ErsatzTV.Core.Health.Checks;
+
+public interface IFFmpegReportsHealthCheck : IHealthCheck
 {
-    public interface IFFmpegReportsHealthCheck : IHealthCheck
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/Checks/IFFmpegVersionHealthCheck.cs b/ErsatzTV.Core/Health/Checks/IFFmpegVersionHealthCheck.cs
index 92c95b3b0..397fb4126 100644
--- a/ErsatzTV.Core/Health/Checks/IFFmpegVersionHealthCheck.cs
+++ b/ErsatzTV.Core/Health/Checks/IFFmpegVersionHealthCheck.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Health.Checks
+namespace ErsatzTV.Core.Health.Checks;
+
+public interface IFFmpegVersionHealthCheck : IHealthCheck
 {
-    public interface IFFmpegVersionHealthCheck : IHealthCheck
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/Checks/IHardwareAccelerationHealthCheck.cs b/ErsatzTV.Core/Health/Checks/IHardwareAccelerationHealthCheck.cs
index 8431fa42b..b90ec10fb 100644
--- a/ErsatzTV.Core/Health/Checks/IHardwareAccelerationHealthCheck.cs
+++ b/ErsatzTV.Core/Health/Checks/IHardwareAccelerationHealthCheck.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Health.Checks
+namespace ErsatzTV.Core.Health.Checks;
+
+public interface IHardwareAccelerationHealthCheck : IHealthCheck
 {
-    public interface IHardwareAccelerationHealthCheck : IHealthCheck
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/Checks/IMovieMetadataHealthCheck.cs b/ErsatzTV.Core/Health/Checks/IMovieMetadataHealthCheck.cs
index ab9ffd207..aee1bac04 100644
--- a/ErsatzTV.Core/Health/Checks/IMovieMetadataHealthCheck.cs
+++ b/ErsatzTV.Core/Health/Checks/IMovieMetadataHealthCheck.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Health.Checks
+namespace ErsatzTV.Core.Health.Checks;
+
+public interface IMovieMetadataHealthCheck : IHealthCheck
 {
-    public interface IMovieMetadataHealthCheck : IHealthCheck
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/Checks/IVaapiDriverHealthCheck.cs b/ErsatzTV.Core/Health/Checks/IVaapiDriverHealthCheck.cs
index dffa83d0e..bd5e6b1d6 100644
--- a/ErsatzTV.Core/Health/Checks/IVaapiDriverHealthCheck.cs
+++ b/ErsatzTV.Core/Health/Checks/IVaapiDriverHealthCheck.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Health.Checks
+namespace ErsatzTV.Core.Health.Checks;
+
+public interface IVaapiDriverHealthCheck : IHealthCheck
 {
-    public interface IVaapiDriverHealthCheck : IHealthCheck
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/Checks/IZeroDurationHealthCheck.cs b/ErsatzTV.Core/Health/Checks/IZeroDurationHealthCheck.cs
index f226b0de8..07b843dc6 100644
--- a/ErsatzTV.Core/Health/Checks/IZeroDurationHealthCheck.cs
+++ b/ErsatzTV.Core/Health/Checks/IZeroDurationHealthCheck.cs
@@ -1,6 +1,5 @@
-namespace ErsatzTV.Core.Health.Checks
+namespace ErsatzTV.Core.Health.Checks;
+
+public interface IZeroDurationHealthCheck : IHealthCheck
 {
-    public interface IZeroDurationHealthCheck : IHealthCheck
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/HealthCheckResult.cs b/ErsatzTV.Core/Health/HealthCheckResult.cs
index 9e3f9ef14..528e50704 100644
--- a/ErsatzTV.Core/Health/HealthCheckResult.cs
+++ b/ErsatzTV.Core/Health/HealthCheckResult.cs
@@ -1,6 +1,3 @@
-using LanguageExt;
+namespace ErsatzTV.Core.Health;
 
-namespace ErsatzTV.Core.Health
-{
-    public record HealthCheckResult(string Title, HealthCheckStatus Status, string Message, Option<string> Link);
-}
+public record HealthCheckResult(string Title, HealthCheckStatus Status, string Message, Option<string> Link);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/HealthCheckStatus.cs b/ErsatzTV.Core/Health/HealthCheckStatus.cs
index 12d661c0f..8dbc1c630 100644
--- a/ErsatzTV.Core/Health/HealthCheckStatus.cs
+++ b/ErsatzTV.Core/Health/HealthCheckStatus.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Core.Health
+namespace ErsatzTV.Core.Health;
+
+public enum HealthCheckStatus
 {
-    public enum HealthCheckStatus
-    {
-        Pass = 0,
-        Fail = 1,
-        Warning = 2,
-        Info = 3,
-        NotApplicable = 4
-    }
-}
+    Pass = 0,
+    Fail = 1,
+    Warning = 2,
+    Info = 3,
+    NotApplicable = 4
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/IHealthCheck.cs b/ErsatzTV.Core/Health/IHealthCheck.cs
index bfe63b6f9..1bf059f3e 100644
--- a/ErsatzTV.Core/Health/IHealthCheck.cs
+++ b/ErsatzTV.Core/Health/IHealthCheck.cs
@@ -1,9 +1,6 @@
-using System.Threading.Tasks;
+namespace ErsatzTV.Core.Health;
 
-namespace ErsatzTV.Core.Health
+public interface IHealthCheck
 {
-    public interface IHealthCheck
-    {
-        Task<HealthCheckResult> Check();
-    }
-}
+    Task<HealthCheckResult> Check();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Health/IHealthCheckService.cs b/ErsatzTV.Core/Health/IHealthCheckService.cs
index 83f85e62a..ad72d3a1b 100644
--- a/ErsatzTV.Core/Health/IHealthCheckService.cs
+++ b/ErsatzTV.Core/Health/IHealthCheckService.cs
@@ -1,10 +1,6 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
+namespace ErsatzTV.Core.Health;
 
-namespace ErsatzTV.Core.Health
+public interface IHealthCheckService
 {
-    public interface IHealthCheckService
-    {
-        Task<List<HealthCheckResult>> PerformHealthChecks();
-    }
-}
+    Task<List<HealthCheckResult>> PerformHealthChecks();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Emby/IEmbyApiClient.cs b/ErsatzTV.Core/Interfaces/Emby/IEmbyApiClient.cs
index c12c15f0a..060192a2e 100644
--- a/ErsatzTV.Core/Interfaces/Emby/IEmbyApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/Emby/IEmbyApiClient.cs
@@ -1,38 +1,34 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Emby
+namespace ErsatzTV.Core.Interfaces.Emby;
+
+public interface IEmbyApiClient
 {
-    public interface IEmbyApiClient
-    {
-        Task<Either<BaseError, EmbyServerInformation>> GetServerInformation(string address, string apiKey);
-        Task<Either<BaseError, List<EmbyLibrary>>> GetLibraries(string address, string apiKey);
+    Task<Either<BaseError, EmbyServerInformation>> GetServerInformation(string address, string apiKey);
+    Task<Either<BaseError, List<EmbyLibrary>>> GetLibraries(string address, string apiKey);
 
-        Task<Either<BaseError, List<EmbyMovie>>> GetMovieLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string libraryId);
+    Task<Either<BaseError, List<EmbyMovie>>> GetMovieLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string libraryId);
 
-        Task<Either<BaseError, List<EmbyShow>>> GetShowLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string libraryId);
+    Task<Either<BaseError, List<EmbyShow>>> GetShowLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string libraryId);
 
-        Task<Either<BaseError, List<EmbySeason>>> GetSeasonLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string showId);
+    Task<Either<BaseError, List<EmbySeason>>> GetSeasonLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string showId);
 
-        Task<Either<BaseError, List<EmbyEpisode>>> GetEpisodeLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string seasonId);
-    }
-}
+    Task<Either<BaseError, List<EmbyEpisode>>> GetEpisodeLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string seasonId);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Emby/IEmbyMovieLibraryScanner.cs b/ErsatzTV.Core/Interfaces/Emby/IEmbyMovieLibraryScanner.cs
index b547a5975..38ddc96fd 100644
--- a/ErsatzTV.Core/Interfaces/Emby/IEmbyMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Emby/IEmbyMovieLibraryScanner.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Emby
+namespace ErsatzTV.Core.Interfaces.Emby;
+
+public interface IEmbyMovieLibraryScanner
 {
-    public interface IEmbyMovieLibraryScanner
-    {
-        Task<Either<BaseError, Unit>> ScanLibrary(
-            string address,
-            string apiKey,
-            EmbyLibrary library,
-            string ffprobePath);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanLibrary(
+        string address,
+        string apiKey,
+        EmbyLibrary library,
+        string ffprobePath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Emby/IEmbyPathReplacementService.cs b/ErsatzTV.Core/Interfaces/Emby/IEmbyPathReplacementService.cs
index 31a4b5864..5d4b1a92f 100644
--- a/ErsatzTV.Core/Interfaces/Emby/IEmbyPathReplacementService.cs
+++ b/ErsatzTV.Core/Interfaces/Emby/IEmbyPathReplacementService.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Emby
+namespace ErsatzTV.Core.Interfaces.Emby;
+
+public interface IEmbyPathReplacementService
 {
-    public interface IEmbyPathReplacementService
-    {
-        Task<string> GetReplacementEmbyPath(int libraryPathId, string path);
-        string GetReplacementEmbyPath(List<EmbyPathReplacement> pathReplacements, string path, bool log = true);
-    }
-}
+    Task<string> GetReplacementEmbyPath(int libraryPathId, string path);
+    string GetReplacementEmbyPath(List<EmbyPathReplacement> pathReplacements, string path, bool log = true);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Emby/IEmbySecretStore.cs b/ErsatzTV.Core/Interfaces/Emby/IEmbySecretStore.cs
index 0c934e75d..f953ef261 100644
--- a/ErsatzTV.Core/Interfaces/Emby/IEmbySecretStore.cs
+++ b/ErsatzTV.Core/Interfaces/Emby/IEmbySecretStore.cs
@@ -1,9 +1,8 @@
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.MediaSources;
 
-namespace ErsatzTV.Core.Interfaces.Emby
+namespace ErsatzTV.Core.Interfaces.Emby;
+
+public interface IEmbySecretStore : IRemoteMediaSourceSecretStore<EmbySecrets>
 {
-    public interface IEmbySecretStore : IRemoteMediaSourceSecretStore<EmbySecrets>
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Emby/IEmbyTelevisionLibraryScanner.cs b/ErsatzTV.Core/Interfaces/Emby/IEmbyTelevisionLibraryScanner.cs
index 7a2453a17..9e7f95989 100644
--- a/ErsatzTV.Core/Interfaces/Emby/IEmbyTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Emby/IEmbyTelevisionLibraryScanner.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Emby
+namespace ErsatzTV.Core.Interfaces.Emby;
+
+public interface IEmbyTelevisionLibraryScanner
 {
-    public interface IEmbyTelevisionLibraryScanner
-    {
-        Task<Either<BaseError, Unit>> ScanLibrary(
-            string address,
-            string apiKey,
-            EmbyLibrary library,
-            string ffprobePath);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanLibrary(
+        string address,
+        string apiKey,
+        EmbyLibrary library,
+        string ffprobePath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/FFmpeg/IDisplaySize.cs b/ErsatzTV.Core/Interfaces/FFmpeg/IDisplaySize.cs
index 36b12cc41..3fb66a162 100644
--- a/ErsatzTV.Core/Interfaces/FFmpeg/IDisplaySize.cs
+++ b/ErsatzTV.Core/Interfaces/FFmpeg/IDisplaySize.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Interfaces.FFmpeg
+namespace ErsatzTV.Core.Interfaces.FFmpeg;
+
+public interface IDisplaySize
 {
-    public interface IDisplaySize
-    {
-        int Width { get; }
-        int Height { get; }
-    }
-}
+    int Width { get; }
+    int Height { get; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegLocator.cs b/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegLocator.cs
index 372623493..aab8f9f0c 100644
--- a/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegLocator.cs
+++ b/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegLocator.cs
@@ -1,11 +1,8 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.FFmpeg
+namespace ErsatzTV.Core.Interfaces.FFmpeg;
+
+public interface IFFmpegLocator
 {
-    public interface IFFmpegLocator
-    {
-        Task<Option<string>> ValidatePath(string executableBase, ConfigElementKey key);
-    }
-}
+    Task<Option<string>> ValidatePath(string executableBase, ConfigElementKey key);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegProcessService.cs b/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegProcessService.cs
index 819a861a2..3f2b94527 100644
--- a/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegProcessService.cs
+++ b/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegProcessService.cs
@@ -1,65 +1,61 @@
-using System;
-using System.Diagnostics;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.FFmpeg
+namespace ErsatzTV.Core.Interfaces.FFmpeg;
+
+public interface IFFmpegProcessService
 {
-    public interface IFFmpegProcessService
-    {
-        Task<Process> ForPlayoutItem(
-            string ffmpegPath,
-            bool saveReports,
-            Channel channel,
-            MediaVersion videoVersion,
-            MediaVersion audioVersion,
-            string videoPath,
-            string audioPath,
-            DateTimeOffset start,
-            DateTimeOffset finish,
-            DateTimeOffset now,
-            Option<ChannelWatermark> globalWatermark,
-            VaapiDriver vaapiDriver,
-            string vaapiDevice,
-            bool hlsRealtime,
-            FillerKind fillerKind,
-            TimeSpan inPoint,
-            TimeSpan outPoint,
-            long ptsOffset,
-            Option<int> targetFramerate);
+    Task<Process> ForPlayoutItem(
+        string ffmpegPath,
+        bool saveReports,
+        Channel channel,
+        MediaVersion videoVersion,
+        MediaVersion audioVersion,
+        string videoPath,
+        string audioPath,
+        DateTimeOffset start,
+        DateTimeOffset finish,
+        DateTimeOffset now,
+        Option<ChannelWatermark> globalWatermark,
+        VaapiDriver vaapiDriver,
+        string vaapiDevice,
+        bool hlsRealtime,
+        FillerKind fillerKind,
+        TimeSpan inPoint,
+        TimeSpan outPoint,
+        long ptsOffset,
+        Option<int> targetFramerate);
 
-        Task<Process> ForError(
-            string ffmpegPath,
-            Channel channel,
-            Option<TimeSpan> duration,
-            string errorMessage,
-            bool hlsRealtime,
-            long ptsOffset);
+    Task<Process> ForError(
+        string ffmpegPath,
+        Channel channel,
+        Option<TimeSpan> duration,
+        string errorMessage,
+        bool hlsRealtime,
+        long ptsOffset);
 
-        Process ConcatChannel(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host);
+    Process ConcatChannel(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host);
 
-        Process WrapSegmenter(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host);
+    Process WrapSegmenter(string ffmpegPath, bool saveReports, Channel channel, string scheme, string host);
 
-        Process ConvertToPng(string ffmpegPath, string inputFile, string outputFile);
+    Process ConvertToPng(string ffmpegPath, string inputFile, string outputFile);
 
-        Process ExtractAttachedPicAsPng(string ffmpegPath, string inputFile, int streamIndex, string outputFile);
+    Process ExtractAttachedPicAsPng(string ffmpegPath, string inputFile, int streamIndex, string outputFile);
 
-        Task<Either<BaseError, string>> GenerateSongImage(
-            string ffmpegPath,
-            Option<string> subtitleFile,
-            Channel channel,
-            Option<ChannelWatermark> globalWatermark,
-            MediaVersion videoVersion,
-            string videoPath,
-            bool boxBlur,
-            Option<string> watermarkPath,
-            WatermarkLocation watermarkLocation,
-            int horizontalMarginPercent,
-            int verticalMarginPercent,
-            int watermarkWidthPercent);
-    }
-}
+    Task<Either<BaseError, string>> GenerateSongImage(
+        string ffmpegPath,
+        Option<string> subtitleFile,
+        Channel channel,
+        Option<ChannelWatermark> globalWatermark,
+        MediaVersion videoVersion,
+        string videoPath,
+        bool boxBlur,
+        Option<string> watermarkPath,
+        WatermarkLocation watermarkLocation,
+        int horizontalMarginPercent,
+        int verticalMarginPercent,
+        int watermarkWidthPercent);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegSegmenterService.cs b/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegSegmenterService.cs
index 32da42aa8..d9a0a4739 100644
--- a/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegSegmenterService.cs
+++ b/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegSegmenterService.cs
@@ -1,11 +1,10 @@
 using System.Collections.Concurrent;
 
-namespace ErsatzTV.Core.Interfaces.FFmpeg
-{
-    public interface IFFmpegSegmenterService
-    {
-        ConcurrentDictionary<string, IHlsSessionWorker> SessionWorkers { get; }
+namespace ErsatzTV.Core.Interfaces.FFmpeg;
 
-        void TouchChannel(string channelNumber);
-    }
-}
+public interface IFFmpegSegmenterService
+{
+    ConcurrentDictionary<string, IHlsSessionWorker> SessionWorkers { get; }
+
+    void TouchChannel(string channelNumber);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegStreamSelector.cs b/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegStreamSelector.cs
index 0ca32f8b6..a5dfbb75e 100644
--- a/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegStreamSelector.cs
+++ b/ErsatzTV.Core/Interfaces/FFmpeg/IFFmpegStreamSelector.cs
@@ -1,12 +1,9 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.FFmpeg
+namespace ErsatzTV.Core.Interfaces.FFmpeg;
+
+public interface IFFmpegStreamSelector
 {
-    public interface IFFmpegStreamSelector
-    {
-        Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version);
-        Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version);
-    }
-}
+    Task<MediaStream> SelectVideoStream(Channel channel, MediaVersion version);
+    Task<Option<MediaStream>> SelectAudioStream(Channel channel, MediaVersion version);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/FFmpeg/IHlsSessionWorker.cs b/ErsatzTV.Core/Interfaces/FFmpeg/IHlsSessionWorker.cs
index cfd24b863..406c157fa 100644
--- a/ErsatzTV.Core/Interfaces/FFmpeg/IHlsSessionWorker.cs
+++ b/ErsatzTV.Core/Interfaces/FFmpeg/IHlsSessionWorker.cs
@@ -1,10 +1,7 @@
-using System;
+namespace ErsatzTV.Core.Interfaces.FFmpeg;
 
-namespace ErsatzTV.Core.Interfaces.FFmpeg
+public interface IHlsSessionWorker
 {
-    public interface IHlsSessionWorker
-    {
-        DateTimeOffset PlaylistStart { get; }
-        void Touch();
-    }
-}
+    DateTimeOffset PlaylistStart { get; }
+    void Touch();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/FFmpeg/ISongVideoGenerator.cs b/ErsatzTV.Core/Interfaces/FFmpeg/ISongVideoGenerator.cs
index 091eb9617..29b3bf2a8 100644
--- a/ErsatzTV.Core/Interfaces/FFmpeg/ISongVideoGenerator.cs
+++ b/ErsatzTV.Core/Interfaces/FFmpeg/ISongVideoGenerator.cs
@@ -1,16 +1,12 @@
-using System;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.FFmpeg
+namespace ErsatzTV.Core.Interfaces.FFmpeg;
+
+public interface ISongVideoGenerator
 {
-    public interface ISongVideoGenerator
-    {
-        Task<Tuple<string, MediaVersion>> GenerateSongVideo(
-            Song song,
-            Channel channel,
-            Option<ChannelWatermark> maybeGlobalWatermark,
-            string ffmpegPath);
-    }
-}
+    Task<Tuple<string, MediaVersion>> GenerateSongVideo(
+        Song song,
+        Channel channel,
+        Option<ChannelWatermark> maybeGlobalWatermark,
+        string ffmpegPath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/FFmpeg/ITempFilePool.cs b/ErsatzTV.Core/Interfaces/FFmpeg/ITempFilePool.cs
index 61eb28911..08e5b5e62 100644
--- a/ErsatzTV.Core/Interfaces/FFmpeg/ITempFilePool.cs
+++ b/ErsatzTV.Core/Interfaces/FFmpeg/ITempFilePool.cs
@@ -1,9 +1,8 @@
 using ErsatzTV.Core.FFmpeg;
 
-namespace ErsatzTV.Core.Interfaces.FFmpeg
+namespace ErsatzTV.Core.Interfaces.FFmpeg;
+
+public interface ITempFilePool
 {
-    public interface ITempFilePool
-    {
-        string GetNextTempFile(TempFileCategory category);
-    }
-}
+    string GetNextTempFile(TempFileCategory category);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/GitHub/IGitHubApiClient.cs b/ErsatzTV.Core/Interfaces/GitHub/IGitHubApiClient.cs
index 5378f44bc..da91b8c38 100644
--- a/ErsatzTV.Core/Interfaces/GitHub/IGitHubApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/GitHub/IGitHubApiClient.cs
@@ -1,12 +1,7 @@
-using System.Threading;
-using System.Threading.Tasks;
-using LanguageExt;
+namespace ErsatzTV.Core.Interfaces.GitHub;
 
-namespace ErsatzTV.Core.Interfaces.GitHub
+public interface IGitHubApiClient
 {
-    public interface IGitHubApiClient
-    {
-        Task<Either<BaseError, string>> GetLatestReleaseNotes(CancellationToken cancellationToken);
-        Task<Either<BaseError, string>> GetReleaseNotes(string tag, CancellationToken cancellationToken);
-    }
-}
+    Task<Either<BaseError, string>> GetLatestReleaseNotes(CancellationToken cancellationToken);
+    Task<Either<BaseError, string>> GetReleaseNotes(string tag, CancellationToken cancellationToken);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Images/IImageCache.cs b/ErsatzTV.Core/Interfaces/Images/IImageCache.cs
index cadaa1e36..4f160b4ef 100644
--- a/ErsatzTV.Core/Interfaces/Images/IImageCache.cs
+++ b/ErsatzTV.Core/Interfaces/Images/IImageCache.cs
@@ -1,19 +1,15 @@
-using System.IO;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Images
+namespace ErsatzTV.Core.Interfaces.Images;
+
+public interface IImageCache
 {
-    public interface IImageCache
-    {
-        Task<Either<BaseError, byte[]>> ResizeImage(byte[] imageBuffer, int height);
-        Task<Either<BaseError, string>> SaveArtworkToCache(Stream stream, ArtworkKind artworkKind);
-        Task<Either<BaseError, string>> CopyArtworkToCache(string path, ArtworkKind artworkKind);
-        string GetPathForImage(string fileName, ArtworkKind artworkKind, Option<int> maybeMaxHeight);
-        Task<bool> IsAnimated(string fileName);
-        Task<string> CalculateBlurHash(string fileName, ArtworkKind artworkKind, int x, int y);
-        Task<string> WriteBlurHash(string blurHash, IDisplaySize targetSize);
-    }
-}
+    Task<Either<BaseError, byte[]>> ResizeImage(byte[] imageBuffer, int height);
+    Task<Either<BaseError, string>> SaveArtworkToCache(Stream stream, ArtworkKind artworkKind);
+    Task<Either<BaseError, string>> CopyArtworkToCache(string path, ArtworkKind artworkKind);
+    string GetPathForImage(string fileName, ArtworkKind artworkKind, Option<int> maybeMaxHeight);
+    Task<bool> IsAnimated(string fileName);
+    Task<string> CalculateBlurHash(string fileName, ArtworkKind artworkKind, int x, int y);
+    Task<string> WriteBlurHash(string blurHash, IDisplaySize targetSize);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs
index 9f1c672f7..a160413ea 100644
--- a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs
@@ -1,39 +1,35 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Jellyfin
+namespace ErsatzTV.Core.Interfaces.Jellyfin;
+
+public interface IJellyfinApiClient
 {
-    public interface IJellyfinApiClient
-    {
-        Task<Either<BaseError, JellyfinServerInformation>> GetServerInformation(string address, string apiKey);
-        Task<Either<BaseError, List<JellyfinLibrary>>> GetLibraries(string address, string apiKey);
-        Task<Either<BaseError, string>> GetAdminUserId(string address, string apiKey);
+    Task<Either<BaseError, JellyfinServerInformation>> GetServerInformation(string address, string apiKey);
+    Task<Either<BaseError, List<JellyfinLibrary>>> GetLibraries(string address, string apiKey);
+    Task<Either<BaseError, string>> GetAdminUserId(string address, string apiKey);
 
-        Task<Either<BaseError, List<JellyfinMovie>>> GetMovieLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string libraryId);
+    Task<Either<BaseError, List<JellyfinMovie>>> GetMovieLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string libraryId);
 
-        Task<Either<BaseError, List<JellyfinShow>>> GetShowLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string libraryId);
+    Task<Either<BaseError, List<JellyfinShow>>> GetShowLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string libraryId);
 
-        Task<Either<BaseError, List<JellyfinSeason>>> GetSeasonLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string showId);
+    Task<Either<BaseError, List<JellyfinSeason>>> GetSeasonLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string showId);
 
-        Task<Either<BaseError, List<JellyfinEpisode>>> GetEpisodeLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string seasonId);
-    }
-}
+    Task<Either<BaseError, List<JellyfinEpisode>>> GetEpisodeLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string seasonId);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinMovieLibraryScanner.cs b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinMovieLibraryScanner.cs
index 911608652..4f54427e3 100644
--- a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinMovieLibraryScanner.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Jellyfin
+namespace ErsatzTV.Core.Interfaces.Jellyfin;
+
+public interface IJellyfinMovieLibraryScanner
 {
-    public interface IJellyfinMovieLibraryScanner
-    {
-        Task<Either<BaseError, Unit>> ScanLibrary(
-            string address,
-            string apiKey,
-            JellyfinLibrary library,
-            string ffprobePath);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanLibrary(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string ffprobePath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinPathReplacementService.cs b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinPathReplacementService.cs
index 4e77503b3..995931db4 100644
--- a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinPathReplacementService.cs
+++ b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinPathReplacementService.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Jellyfin
+namespace ErsatzTV.Core.Interfaces.Jellyfin;
+
+public interface IJellyfinPathReplacementService
 {
-    public interface IJellyfinPathReplacementService
-    {
-        Task<string> GetReplacementJellyfinPath(int libraryPathId, string path);
-        string GetReplacementJellyfinPath(List<JellyfinPathReplacement> pathReplacements, string path, bool log = true);
-    }
-}
+    Task<string> GetReplacementJellyfinPath(int libraryPathId, string path);
+    string GetReplacementJellyfinPath(List<JellyfinPathReplacement> pathReplacements, string path, bool log = true);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinSecretStore.cs b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinSecretStore.cs
index 1339cb81c..6620ff5aa 100644
--- a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinSecretStore.cs
+++ b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinSecretStore.cs
@@ -1,9 +1,8 @@
 using ErsatzTV.Core.Interfaces.MediaSources;
 using ErsatzTV.Core.Jellyfin;
 
-namespace ErsatzTV.Core.Interfaces.Jellyfin
+namespace ErsatzTV.Core.Interfaces.Jellyfin;
+
+public interface IJellyfinSecretStore : IRemoteMediaSourceSecretStore<JellyfinSecrets>
 {
-    public interface IJellyfinSecretStore : IRemoteMediaSourceSecretStore<JellyfinSecrets>
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinTelevisionLibraryScanner.cs b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinTelevisionLibraryScanner.cs
index 1ae43a008..a82d77caa 100644
--- a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinTelevisionLibraryScanner.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Jellyfin
+namespace ErsatzTV.Core.Interfaces.Jellyfin;
+
+public interface IJellyfinTelevisionLibraryScanner
 {
-    public interface IJellyfinTelevisionLibraryScanner
-    {
-        Task<Either<BaseError, Unit>> ScanLibrary(
-            string address,
-            string apiKey,
-            JellyfinLibrary library,
-            string ffprobePath);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanLibrary(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string ffprobePath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Locking/IEntityLocker.cs b/ErsatzTV.Core/Interfaces/Locking/IEntityLocker.cs
index 9c8a92345..91fff1d29 100644
--- a/ErsatzTV.Core/Interfaces/Locking/IEntityLocker.cs
+++ b/ErsatzTV.Core/Interfaces/Locking/IEntityLocker.cs
@@ -1,24 +1,21 @@
-using System;
+namespace ErsatzTV.Core.Interfaces.Locking;
 
-namespace ErsatzTV.Core.Interfaces.Locking
+public interface IEntityLocker
 {
-    public interface IEntityLocker
-    {
-        event EventHandler OnLibraryChanged;
-        event EventHandler OnPlexChanged;
-        event EventHandler<Type> OnRemoteMediaSourceChanged;
-        event EventHandler OnTraktChanged;
-        bool LockLibrary(int libraryId);
-        bool UnlockLibrary(int libraryId);
-        bool IsLibraryLocked(int libraryId);
-        bool LockPlex();
-        bool UnlockPlex();
-        bool IsPlexLocked();
-        bool IsRemoteMediaSourceLocked<TMediaSource>();
-        bool LockRemoteMediaSource<TMediaSource>();
-        bool UnlockRemoteMediaSource<TMediaSource>();
-        bool IsTraktLocked();
-        bool LockTrakt();
-        bool UnlockTrakt();
-    }
-}
+    event EventHandler OnLibraryChanged;
+    event EventHandler OnPlexChanged;
+    event EventHandler<Type> OnRemoteMediaSourceChanged;
+    event EventHandler OnTraktChanged;
+    bool LockLibrary(int libraryId);
+    bool UnlockLibrary(int libraryId);
+    bool IsLibraryLocked(int libraryId);
+    bool LockPlex();
+    bool UnlockPlex();
+    bool IsPlexLocked();
+    bool IsRemoteMediaSourceLocked<TMediaSource>();
+    bool LockRemoteMediaSource<TMediaSource>();
+    bool UnlockRemoteMediaSource<TMediaSource>();
+    bool IsTraktLocked();
+    bool LockTrakt();
+    bool UnlockTrakt();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/MediaSources/IRemoteMediaSourceSecretStore.cs b/ErsatzTV.Core/Interfaces/MediaSources/IRemoteMediaSourceSecretStore.cs
index 5afe030a7..37342d11e 100644
--- a/ErsatzTV.Core/Interfaces/MediaSources/IRemoteMediaSourceSecretStore.cs
+++ b/ErsatzTV.Core/Interfaces/MediaSources/IRemoteMediaSourceSecretStore.cs
@@ -1,12 +1,8 @@
-using System.Threading.Tasks;
-using LanguageExt;
+namespace ErsatzTV.Core.Interfaces.MediaSources;
 
-namespace ErsatzTV.Core.Interfaces.MediaSources
+public interface IRemoteMediaSourceSecretStore<TSecrets>
 {
-    public interface IRemoteMediaSourceSecretStore<TSecrets>
-    {
-        Task<Unit> DeleteAll();
-        Task<TSecrets> ReadSecrets();
-        Task<Unit> SaveSecrets(TSecrets jellyfinSecrets);
-    }
-}
+    Task<Unit> DeleteAll();
+    Task<TSecrets> ReadSecrets();
+    Task<Unit> SaveSecrets(TSecrets jellyfinSecrets);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/IFallbackMetadataProvider.cs b/ErsatzTV.Core/Interfaces/Metadata/IFallbackMetadataProvider.cs
index 1d1f1cfa2..284d76671 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/IFallbackMetadataProvider.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/IFallbackMetadataProvider.cs
@@ -1,18 +1,15 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface IFallbackMetadataProvider
 {
-    public interface IFallbackMetadataProvider
-    {
-        ShowMetadata GetFallbackMetadataForShow(string showFolder);
-        ArtistMetadata GetFallbackMetadataForArtist(string artistFolder);
-        List<EpisodeMetadata> GetFallbackMetadata(Episode episode);
-        MovieMetadata GetFallbackMetadata(Movie movie);
-        Option<MusicVideoMetadata> GetFallbackMetadata(MusicVideo musicVideo);
-        Option<OtherVideoMetadata> GetFallbackMetadata(OtherVideo otherVideo);
-        Option<SongMetadata> GetFallbackMetadata(Song song);
-        string GetSortTitle(string title);
-    }
-}
+    ShowMetadata GetFallbackMetadataForShow(string showFolder);
+    ArtistMetadata GetFallbackMetadataForArtist(string artistFolder);
+    List<EpisodeMetadata> GetFallbackMetadata(Episode episode);
+    MovieMetadata GetFallbackMetadata(Movie movie);
+    Option<MusicVideoMetadata> GetFallbackMetadata(MusicVideo musicVideo);
+    Option<OtherVideoMetadata> GetFallbackMetadata(OtherVideo otherVideo);
+    Option<SongMetadata> GetFallbackMetadata(Song song);
+    string GetSortTitle(string title);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/ILocalFileSystem.cs b/ErsatzTV.Core/Interfaces/Metadata/ILocalFileSystem.cs
index 5729ca7a3..8849cca17 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/ILocalFileSystem.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/ILocalFileSystem.cs
@@ -1,21 +1,16 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface ILocalFileSystem
 {
-    public interface ILocalFileSystem
-    {
-        Unit EnsureFolderExists(string folder);
-        DateTime GetLastWriteTime(string path);
-        bool IsLibraryPathAccessible(LibraryPath libraryPath);
-        IEnumerable<string> ListSubdirectories(string folder);
-        IEnumerable<string> ListFiles(string folder);
-        bool FileExists(string path);
-        bool FolderExists(string folder);
-        Task<Either<BaseError, Unit>> CopyFile(string source, string destination);
-        Unit EmptyFolder(string folder);
-    }
-}
+    Unit EnsureFolderExists(string folder);
+    DateTime GetLastWriteTime(string path);
+    bool IsLibraryPathAccessible(LibraryPath libraryPath);
+    IEnumerable<string> ListSubdirectories(string folder);
+    IEnumerable<string> ListFiles(string folder);
+    bool FileExists(string path);
+    bool FolderExists(string folder);
+    Task<Either<BaseError, Unit>> CopyFile(string source, string destination);
+    Unit EmptyFolder(string folder);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs b/ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs
index dc44ef976..7e3188f80 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/ILocalMetadataProvider.cs
@@ -1,24 +1,22 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface ILocalMetadataProvider
 {
-    public interface ILocalMetadataProvider
-    {
-        Task<ShowMetadata> GetMetadataForShow(string showFolder);
-        Task<ArtistMetadata> GetMetadataForArtist(string artistFolder);
-        Task<bool> RefreshSidecarMetadata(Movie movie, string nfoFileName);
-        Task<bool> RefreshSidecarMetadata(Show televisionShow, string nfoFileName);
-        Task<bool> RefreshSidecarMetadata(Episode episode, string nfoFileName);
-        Task<bool> RefreshSidecarMetadata(Artist artist, string nfoFileName);
-        Task<bool> RefreshSidecarMetadata(MusicVideo musicVideo, string nfoFileName);
-        Task<bool> RefreshTagMetadata(Song song, string ffprobePath);
-        Task<bool> RefreshFallbackMetadata(Movie movie);
-        Task<bool> RefreshFallbackMetadata(Episode episode);
-        Task<bool> RefreshFallbackMetadata(Artist artist, string artistFolder);
-        Task<bool> RefreshFallbackMetadata(MusicVideo musicVideo);
-        Task<bool> RefreshFallbackMetadata(OtherVideo otherVideo);
-        Task<bool> RefreshFallbackMetadata(Song song);
-        Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder);
-    }
-}
+    Task<ShowMetadata> GetMetadataForShow(string showFolder);
+    Task<ArtistMetadata> GetMetadataForArtist(string artistFolder);
+    Task<bool> RefreshSidecarMetadata(Movie movie, string nfoFileName);
+    Task<bool> RefreshSidecarMetadata(Show televisionShow, string nfoFileName);
+    Task<bool> RefreshSidecarMetadata(Episode episode, string nfoFileName);
+    Task<bool> RefreshSidecarMetadata(Artist artist, string nfoFileName);
+    Task<bool> RefreshSidecarMetadata(MusicVideo musicVideo, string nfoFileName);
+    Task<bool> RefreshTagMetadata(Song song, string ffprobePath);
+    Task<bool> RefreshFallbackMetadata(Movie movie);
+    Task<bool> RefreshFallbackMetadata(Episode episode);
+    Task<bool> RefreshFallbackMetadata(Artist artist, string artistFolder);
+    Task<bool> RefreshFallbackMetadata(MusicVideo musicVideo);
+    Task<bool> RefreshFallbackMetadata(OtherVideo otherVideo);
+    Task<bool> RefreshFallbackMetadata(Song song);
+    Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs b/ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs
index f3770e2d7..c500e595b 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs
@@ -1,15 +1,11 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface ILocalStatisticsProvider
 {
-    public interface ILocalStatisticsProvider
-    {
-        Task<Either<BaseError, bool>> RefreshStatistics(string ffprobePath, MediaItem mediaItem);
-        Task<Either<BaseError, bool>> RefreshStatistics(string ffprobePath, MediaItem mediaItem, string mediaItemPath);
+    Task<Either<BaseError, bool>> RefreshStatistics(string ffprobePath, MediaItem mediaItem);
+    Task<Either<BaseError, bool>> RefreshStatistics(string ffprobePath, MediaItem mediaItem, string mediaItemPath);
 
-        Task<Either<BaseError, Dictionary<string, string>>> GetFormatTags(string ffprobePath, MediaItem mediaItem);
-    }
-}
+    Task<Either<BaseError, Dictionary<string, string>>> GetFormatTags(string ffprobePath, MediaItem mediaItem);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/IMovieFolderScanner.cs b/ErsatzTV.Core/Interfaces/Metadata/IMovieFolderScanner.cs
index cbe115c16..9ff687516 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/IMovieFolderScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/IMovieFolderScanner.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface IMovieFolderScanner
 {
-    public interface IMovieFolderScanner
-    {
-        Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            decimal progressMin,
-            decimal progressMax);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        decimal progressMin,
+        decimal progressMax);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/IMusicVideoFolderScanner.cs b/ErsatzTV.Core/Interfaces/Metadata/IMusicVideoFolderScanner.cs
index 4a80c77ae..f72387eea 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/IMusicVideoFolderScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/IMusicVideoFolderScanner.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface IMusicVideoFolderScanner
 {
-    public interface IMusicVideoFolderScanner
-    {
-        Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            decimal progressMin,
-            decimal progressMax);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        decimal progressMin,
+        decimal progressMax);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/IOtherVideoFolderScanner.cs b/ErsatzTV.Core/Interfaces/Metadata/IOtherVideoFolderScanner.cs
index b5ed2738c..d10fe9e78 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/IOtherVideoFolderScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/IOtherVideoFolderScanner.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface IOtherVideoFolderScanner
 {
-    public interface IOtherVideoFolderScanner
-    {
-        Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            decimal progressMin,
-            decimal progressMax);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        decimal progressMin,
+        decimal progressMax);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/ISongFolderScanner.cs b/ErsatzTV.Core/Interfaces/Metadata/ISongFolderScanner.cs
index a15b984d1..8cdbf41a2 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/ISongFolderScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/ISongFolderScanner.cs
@@ -1,16 +1,13 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface ISongFolderScanner
 {
-    public interface ISongFolderScanner
-    {
-        Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            string ffmpegPath,
-            decimal progressMin,
-            decimal progressMax);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        string ffmpegPath,
+        decimal progressMin,
+        decimal progressMax);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/ITelevisionFolderScanner.cs b/ErsatzTV.Core/Interfaces/Metadata/ITelevisionFolderScanner.cs
index 6541d4381..c17a53eb5 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/ITelevisionFolderScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/ITelevisionFolderScanner.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Metadata
+namespace ErsatzTV.Core.Interfaces.Metadata;
+
+public interface ITelevisionFolderScanner
 {
-    public interface ITelevisionFolderScanner
-    {
-        Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            decimal progressMin,
-            decimal progressMax);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        decimal progressMin,
+        decimal progressMax);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Metadata/Nfo/IEpisodeNfoReader.cs b/ErsatzTV.Core/Interfaces/Metadata/Nfo/IEpisodeNfoReader.cs
index d8d622dea..86a91cf85 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/Nfo/IEpisodeNfoReader.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/Nfo/IEpisodeNfoReader.cs
@@ -1,12 +1,8 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Metadata.Nfo;
+using ErsatzTV.Core.Metadata.Nfo;
 
-namespace ErsatzTV.Core.Interfaces.Metadata.Nfo
+namespace ErsatzTV.Core.Interfaces.Metadata.Nfo;
+
+public interface IEpisodeNfoReader
 {
-    public interface IEpisodeNfoReader
-    {
-        Task<List<TvShowEpisodeNfo>> Read(Stream input);
-    }
-}
+    Task<List<TvShowEpisodeNfo>> Read(Stream input);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Plex/IPlexMovieLibraryScanner.cs b/ErsatzTV.Core/Interfaces/Plex/IPlexMovieLibraryScanner.cs
index ebdcc8705..ac0dade70 100644
--- a/ErsatzTV.Core/Interfaces/Plex/IPlexMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Plex/IPlexMovieLibraryScanner.cs
@@ -1,16 +1,13 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Plex
+namespace ErsatzTV.Core.Interfaces.Plex;
+
+public interface IPlexMovieLibraryScanner
 {
-    public interface IPlexMovieLibraryScanner
-    {
-        Task<Either<BaseError, Unit>> ScanLibrary(
-            PlexConnection connection,
-            PlexServerAuthToken token,
-            PlexLibrary library,
-            string ffprobePath);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanLibrary(
+        PlexConnection connection,
+        PlexServerAuthToken token,
+        PlexLibrary library,
+        string ffprobePath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Plex/IPlexPathReplacementService.cs b/ErsatzTV.Core/Interfaces/Plex/IPlexPathReplacementService.cs
index 1a3410f12..8b9b7151b 100644
--- a/ErsatzTV.Core/Interfaces/Plex/IPlexPathReplacementService.cs
+++ b/ErsatzTV.Core/Interfaces/Plex/IPlexPathReplacementService.cs
@@ -1,12 +1,9 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Plex
+namespace ErsatzTV.Core.Interfaces.Plex;
+
+public interface IPlexPathReplacementService
 {
-    public interface IPlexPathReplacementService
-    {
-        Task<string> GetReplacementPlexPath(int libraryPathId, string path);
-        string GetReplacementPlexPath(List<PlexPathReplacement> pathReplacements, string path, bool log = true);
-    }
-}
+    Task<string> GetReplacementPlexPath(int libraryPathId, string path);
+    string GetReplacementPlexPath(List<PlexPathReplacement> pathReplacements, string path, bool log = true);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Plex/IPlexSecretStore.cs b/ErsatzTV.Core/Interfaces/Plex/IPlexSecretStore.cs
index 045d98499..dd59e6f9c 100644
--- a/ErsatzTV.Core/Interfaces/Plex/IPlexSecretStore.cs
+++ b/ErsatzTV.Core/Interfaces/Plex/IPlexSecretStore.cs
@@ -1,17 +1,13 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Plex;
-using LanguageExt;
+using ErsatzTV.Core.Plex;
 
-namespace ErsatzTV.Core.Interfaces.Plex
+namespace ErsatzTV.Core.Interfaces.Plex;
+
+public interface IPlexSecretStore
 {
-    public interface IPlexSecretStore
-    {
-        Task<string> GetClientIdentifier();
-        Task<List<PlexUserAuthToken>> GetUserAuthTokens();
-        Task<Unit> UpsertUserAuthToken(PlexUserAuthToken userAuthToken);
-        Task<Option<PlexServerAuthToken>> GetServerAuthToken(string clientIdentifier);
-        Task<Unit> UpsertServerAuthToken(PlexServerAuthToken serverAuthToken);
-        Task<Unit> DeleteAll();
-    }
-}
+    Task<string> GetClientIdentifier();
+    Task<List<PlexUserAuthToken>> GetUserAuthTokens();
+    Task<Unit> UpsertUserAuthToken(PlexUserAuthToken userAuthToken);
+    Task<Option<PlexServerAuthToken>> GetServerAuthToken(string clientIdentifier);
+    Task<Unit> UpsertServerAuthToken(PlexServerAuthToken serverAuthToken);
+    Task<Unit> DeleteAll();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Plex/IPlexServerApiClient.cs b/ErsatzTV.Core/Interfaces/Plex/IPlexServerApiClient.cs
index aa13e19d2..24890cfd3 100644
--- a/ErsatzTV.Core/Interfaces/Plex/IPlexServerApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/Plex/IPlexServerApiClient.cs
@@ -1,66 +1,61 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Plex
+namespace ErsatzTV.Core.Interfaces.Plex;
+
+public interface IPlexServerApiClient
 {
-    public interface IPlexServerApiClient
-    {
-        Task<bool> Ping(
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<bool> Ping(
+        PlexConnection connection,
+        PlexServerAuthToken token);
         
-        Task<Either<BaseError, List<PlexLibrary>>> GetLibraries(
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<Either<BaseError, List<PlexLibrary>>> GetLibraries(
+        PlexConnection connection,
+        PlexServerAuthToken token);
 
-        Task<Either<BaseError, List<PlexMovie>>> GetMovieLibraryContents(
-            PlexLibrary library,
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<Either<BaseError, List<PlexMovie>>> GetMovieLibraryContents(
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token);
 
-        Task<Either<BaseError, List<PlexShow>>> GetShowLibraryContents(
-            PlexLibrary library,
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<Either<BaseError, List<PlexShow>>> GetShowLibraryContents(
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token);
 
-        Task<Either<BaseError, List<PlexSeason>>> GetShowSeasons(
-            PlexLibrary library,
-            PlexShow show,
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<Either<BaseError, List<PlexSeason>>> GetShowSeasons(
+        PlexLibrary library,
+        PlexShow show,
+        PlexConnection connection,
+        PlexServerAuthToken token);
 
-        Task<Either<BaseError, List<PlexEpisode>>> GetSeasonEpisodes(
-            PlexLibrary library,
-            PlexSeason season,
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<Either<BaseError, List<PlexEpisode>>> GetSeasonEpisodes(
+        PlexLibrary library,
+        PlexSeason season,
+        PlexConnection connection,
+        PlexServerAuthToken token);
 
-        Task<Either<BaseError, MovieMetadata>> GetMovieMetadata(
-            PlexLibrary library,
-            string key,
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<Either<BaseError, MovieMetadata>> GetMovieMetadata(
+        PlexLibrary library,
+        string key,
+        PlexConnection connection,
+        PlexServerAuthToken token);
 
-        Task<Either<BaseError, ShowMetadata>> GetShowMetadata(
-            PlexLibrary library,
-            string key,
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<Either<BaseError, ShowMetadata>> GetShowMetadata(
+        PlexLibrary library,
+        string key,
+        PlexConnection connection,
+        PlexServerAuthToken token);
 
-        Task<Either<BaseError, Tuple<MovieMetadata, MediaVersion>>> GetMovieMetadataAndStatistics(
-            PlexLibrary library,
-            string key,
-            PlexConnection connection,
-            PlexServerAuthToken token);
+    Task<Either<BaseError, Tuple<MovieMetadata, MediaVersion>>> GetMovieMetadataAndStatistics(
+        PlexLibrary library,
+        string key,
+        PlexConnection connection,
+        PlexServerAuthToken token);
 
-        Task<Either<BaseError, Tuple<EpisodeMetadata, MediaVersion>>> GetEpisodeMetadataAndStatistics(
-            PlexLibrary library,
-            string key,
-            PlexConnection connection,
-            PlexServerAuthToken token);
-    }
-}
+    Task<Either<BaseError, Tuple<EpisodeMetadata, MediaVersion>>> GetEpisodeMetadataAndStatistics(
+        PlexLibrary library,
+        string key,
+        PlexConnection connection,
+        PlexServerAuthToken token);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Plex/IPlexTelevisionLibraryScanner.cs b/ErsatzTV.Core/Interfaces/Plex/IPlexTelevisionLibraryScanner.cs
index 9a507002f..1fea83b46 100644
--- a/ErsatzTV.Core/Interfaces/Plex/IPlexTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Interfaces/Plex/IPlexTelevisionLibraryScanner.cs
@@ -1,16 +1,13 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Plex
+namespace ErsatzTV.Core.Interfaces.Plex;
+
+public interface IPlexTelevisionLibraryScanner
 {
-    public interface IPlexTelevisionLibraryScanner
-    {
-        Task<Either<BaseError, Unit>> ScanLibrary(
-            PlexConnection connection,
-            PlexServerAuthToken token,
-            PlexLibrary library,
-            string ffprobePath);
-    }
-}
+    Task<Either<BaseError, Unit>> ScanLibrary(
+        PlexConnection connection,
+        PlexServerAuthToken token,
+        PlexLibrary library,
+        string ffprobePath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Plex/IPlexTvApiClient.cs b/ErsatzTV.Core/Interfaces/Plex/IPlexTvApiClient.cs
index c71f29965..3a30498ff 100644
--- a/ErsatzTV.Core/Interfaces/Plex/IPlexTvApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/Plex/IPlexTvApiClient.cs
@@ -1,15 +1,11 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Plex
+namespace ErsatzTV.Core.Interfaces.Plex;
+
+public interface IPlexTvApiClient
 {
-    public interface IPlexTvApiClient
-    {
-        Task<Either<BaseError, PlexAuthPin>> StartPinFlow();
-        Task<bool> TryCompletePinFlow(PlexAuthPin authPin);
-        Task<Either<BaseError, List<PlexMediaSource>>> GetServers();
-    }
-}
+    Task<Either<BaseError, PlexAuthPin>> StartPinFlow();
+    Task<bool> TryCompletePinFlow(PlexAuthPin authPin);
+    Task<Either<BaseError, List<PlexMediaSource>>> GetServers();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IArtistRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IArtistRepository.cs
index 648bcb92e..1fd030b6a 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IArtistRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IArtistRepository.cs
@@ -1,27 +1,23 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IArtistRepository
 {
-    public interface IArtistRepository
-    {
-        Task<Option<Artist>> GetArtistByMetadata(int libraryPathId, ArtistMetadata metadata);
+    Task<Option<Artist>> GetArtistByMetadata(int libraryPathId, ArtistMetadata metadata);
 
-        Task<Either<BaseError, MediaItemScanResult<Artist>>> AddArtist(
-            int libraryPathId,
-            string artistFolder,
-            ArtistMetadata metadata);
+    Task<Either<BaseError, MediaItemScanResult<Artist>>> AddArtist(
+        int libraryPathId,
+        string artistFolder,
+        ArtistMetadata metadata);
 
-        Task<List<int>> DeleteEmptyArtists(LibraryPath libraryPath);
-        Task<Option<Artist>> GetArtist(int artistId);
-        Task<List<ArtistMetadata>> GetArtistsForCards(List<int> ids);
-        Task<bool> AddGenre(ArtistMetadata metadata, Genre genre);
-        Task<bool> AddStyle(ArtistMetadata metadata, Style style);
-        Task<bool> AddMood(ArtistMetadata metadata, Mood mood);
-        Task<List<MusicVideo>> GetArtistItems(int artistId);
-        Task<List<Artist>> GetAllArtists();
-    }
-}
+    Task<List<int>> DeleteEmptyArtists(LibraryPath libraryPath);
+    Task<Option<Artist>> GetArtist(int artistId);
+    Task<List<ArtistMetadata>> GetArtistsForCards(List<int> ids);
+    Task<bool> AddGenre(ArtistMetadata metadata, Genre genre);
+    Task<bool> AddStyle(ArtistMetadata metadata, Style style);
+    Task<bool> AddMood(ArtistMetadata metadata, Mood mood);
+    Task<List<MusicVideo>> GetArtistItems(int artistId);
+    Task<List<Artist>> GetAllArtists();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IArtworkRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IArtworkRepository.cs
index 67fec6ee1..e692e1b93 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IArtworkRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IArtworkRepository.cs
@@ -1,13 +1,9 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IArtworkRepository
 {
-    public interface IArtworkRepository
-    {
-        Task<List<Artwork>> GetOrphanedArtwork();
-        Task<Unit> Delete(List<Artwork> artwork);
-    }
-}
+    Task<List<Artwork>> GetOrphanedArtwork();
+    Task<Unit> Delete(List<Artwork> artwork);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IChannelRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IChannelRepository.cs
index 9895b218d..f486bc5e2 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IChannelRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IChannelRepository.cs
@@ -1,16 +1,12 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IChannelRepository
 {
-    public interface IChannelRepository
-    {
-        Task<Option<Channel>> Get(int id);
-        Task<Option<Channel>> GetByNumber(string number);
-        Task<List<Channel>> GetAll();
-        Task<List<Channel>> GetAllForGuide();
-        Task Delete(int channelId);
-    }
-}
+    Task<Option<Channel>> Get(int id);
+    Task<Option<Channel>> GetByNumber(string number);
+    Task<List<Channel>> GetAll();
+    Task<List<Channel>> GetAllForGuide();
+    Task Delete(int channelId);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IConfigElementRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IConfigElementRepository.cs
index fdc33982b..c3dd16631 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IConfigElementRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IConfigElementRepository.cs
@@ -1,15 +1,12 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IConfigElementRepository
 {
-    public interface IConfigElementRepository
-    {
-        Task<Unit> Upsert<T>(ConfigElementKey configElementKey, T value);
-        Task<Option<ConfigElement>> Get(ConfigElementKey key);
-        Task<Option<T>> GetValue<T>(ConfigElementKey key);
-        Task Delete(ConfigElement configElement);
-        Task<Unit> Delete(ConfigElementKey configElementKey);
-    }
-}
+    Task<Unit> Upsert<T>(ConfigElementKey configElementKey, T value);
+    Task<Option<ConfigElement>> Get(ConfigElementKey key);
+    Task<Option<T>> GetValue<T>(ConfigElementKey key);
+    Task Delete(ConfigElement configElement);
+    Task<Unit> Delete(ConfigElementKey configElementKey);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IEmbyTelevisionRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IEmbyTelevisionRepository.cs
index bbc7e24f1..562a12ab6 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IEmbyTelevisionRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IEmbyTelevisionRepository.cs
@@ -1,26 +1,22 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IEmbyTelevisionRepository
 {
-    public interface IEmbyTelevisionRepository
-    {
-        Task<List<EmbyItemEtag>> GetExistingShows(EmbyLibrary library);
-        Task<List<EmbyItemEtag>> GetExistingSeasons(EmbyLibrary library, string showItemId);
-        Task<List<EmbyItemEtag>> GetExistingEpisodes(EmbyLibrary library, string seasonItemId);
-        Task<bool> AddShow(EmbyShow show);
-        Task<Option<EmbyShow>> Update(EmbyShow show);
-        Task<bool> AddSeason(EmbyShow show, EmbySeason season);
-        Task<Option<EmbySeason>> Update(EmbySeason season);
-        Task<bool> AddEpisode(EmbySeason season, EmbyEpisode episode);
-        Task<Option<EmbyEpisode>> Update(EmbyEpisode episode);
-        Task<List<int>> RemoveMissingShows(EmbyLibrary library, List<string> showIds);
-        Task<Unit> RemoveMissingSeasons(EmbyLibrary library, List<string> seasonIds);
-        Task<List<int>> RemoveMissingEpisodes(EmbyLibrary library, List<string> episodeIds);
-        Task<Unit> DeleteEmptySeasons(EmbyLibrary library);
-        Task<List<int>> DeleteEmptyShows(EmbyLibrary library);
-    }
-}
+    Task<List<EmbyItemEtag>> GetExistingShows(EmbyLibrary library);
+    Task<List<EmbyItemEtag>> GetExistingSeasons(EmbyLibrary library, string showItemId);
+    Task<List<EmbyItemEtag>> GetExistingEpisodes(EmbyLibrary library, string seasonItemId);
+    Task<bool> AddShow(EmbyShow show);
+    Task<Option<EmbyShow>> Update(EmbyShow show);
+    Task<bool> AddSeason(EmbyShow show, EmbySeason season);
+    Task<Option<EmbySeason>> Update(EmbySeason season);
+    Task<bool> AddEpisode(EmbySeason season, EmbyEpisode episode);
+    Task<Option<EmbyEpisode>> Update(EmbyEpisode episode);
+    Task<List<int>> RemoveMissingShows(EmbyLibrary library, List<string> showIds);
+    Task<Unit> RemoveMissingSeasons(EmbyLibrary library, List<string> seasonIds);
+    Task<List<int>> RemoveMissingEpisodes(EmbyLibrary library, List<string> episodeIds);
+    Task<Unit> DeleteEmptySeasons(EmbyLibrary library);
+    Task<List<int>> DeleteEmptyShows(EmbyLibrary library);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IFFmpegProfileRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IFFmpegProfileRepository.cs
index bc378ff85..27b46ecef 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IFFmpegProfileRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IFFmpegProfileRepository.cs
@@ -1,10 +1,8 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IFFmpegProfileRepository
 {
-    public interface IFFmpegProfileRepository
-    {
-        Task<FFmpegProfile> Copy(int ffmpegProfileId, string name);
-    }
-}
+    Task<FFmpegProfile> Copy(int ffmpegProfileId, string name);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IJellyfinTelevisionRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IJellyfinTelevisionRepository.cs
index f39dbd2ed..d30b19259 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IJellyfinTelevisionRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IJellyfinTelevisionRepository.cs
@@ -1,26 +1,22 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IJellyfinTelevisionRepository
 {
-    public interface IJellyfinTelevisionRepository
-    {
-        Task<List<JellyfinItemEtag>> GetExistingShows(JellyfinLibrary library);
-        Task<List<JellyfinItemEtag>> GetExistingSeasons(JellyfinLibrary library, string showItemId);
-        Task<List<JellyfinItemEtag>> GetExistingEpisodes(JellyfinLibrary library, string seasonItemId);
-        Task<bool> AddShow(JellyfinShow show);
-        Task<Option<JellyfinShow>> Update(JellyfinShow show);
-        Task<bool> AddSeason(JellyfinShow show, JellyfinSeason season);
-        Task<Option<JellyfinSeason>> Update(JellyfinSeason season);
-        Task<bool> AddEpisode(JellyfinSeason season, JellyfinEpisode episode);
-        Task<Option<JellyfinEpisode>> Update(JellyfinEpisode episode);
-        Task<List<int>> RemoveMissingShows(JellyfinLibrary library, List<string> showIds);
-        Task<Unit> RemoveMissingSeasons(JellyfinLibrary library, List<string> seasonIds);
-        Task<List<int>> RemoveMissingEpisodes(JellyfinLibrary library, List<string> episodeIds);
-        Task<Unit> DeleteEmptySeasons(JellyfinLibrary library);
-        Task<List<int>> DeleteEmptyShows(JellyfinLibrary library);
-    }
-}
+    Task<List<JellyfinItemEtag>> GetExistingShows(JellyfinLibrary library);
+    Task<List<JellyfinItemEtag>> GetExistingSeasons(JellyfinLibrary library, string showItemId);
+    Task<List<JellyfinItemEtag>> GetExistingEpisodes(JellyfinLibrary library, string seasonItemId);
+    Task<bool> AddShow(JellyfinShow show);
+    Task<Option<JellyfinShow>> Update(JellyfinShow show);
+    Task<bool> AddSeason(JellyfinShow show, JellyfinSeason season);
+    Task<Option<JellyfinSeason>> Update(JellyfinSeason season);
+    Task<bool> AddEpisode(JellyfinSeason season, JellyfinEpisode episode);
+    Task<Option<JellyfinEpisode>> Update(JellyfinEpisode episode);
+    Task<List<int>> RemoveMissingShows(JellyfinLibrary library, List<string> showIds);
+    Task<Unit> RemoveMissingSeasons(JellyfinLibrary library, List<string> seasonIds);
+    Task<List<int>> RemoveMissingEpisodes(JellyfinLibrary library, List<string> episodeIds);
+    Task<Unit> DeleteEmptySeasons(JellyfinLibrary library);
+    Task<List<int>> DeleteEmptyShows(JellyfinLibrary library);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/ILibraryRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/ILibraryRepository.cs
index daafe300c..0597ed3f0 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/ILibraryRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/ILibraryRepository.cs
@@ -1,24 +1,20 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface ILibraryRepository
 {
-    public interface ILibraryRepository
-    {
-        Task<LibraryPath> Add(LibraryPath libraryPath);
-        Task<Option<Library>> Get(int libraryId);
-        Task<Option<LocalLibrary>> GetLocal(int libraryId);
-        Task<List<Library>> GetAll();
-        Task<Unit> UpdateLastScan(Library library);
-        Task<Unit> UpdateLastScan(LibraryPath libraryPath);
-        Task<List<LibraryPath>> GetLocalPaths(int libraryId);
-        Task<Option<LibraryPath>> GetPath(int libraryPathId);
-        Task<int> CountMediaItemsByPath(int libraryPathId);
-        Task<List<int>> GetMediaIdsByLocalPath(int libraryPathId);
-        Task DeleteLocalPath(int libraryPathId);
-        Task<Unit> SetEtag(LibraryPath libraryPath, Option<LibraryFolder> knownFolder, string path, string etag);
-        Task<Unit> CleanEtagsForLibraryPath(LibraryPath libraryPath);
-    }
-}
+    Task<LibraryPath> Add(LibraryPath libraryPath);
+    Task<Option<Library>> Get(int libraryId);
+    Task<Option<LocalLibrary>> GetLocal(int libraryId);
+    Task<List<Library>> GetAll();
+    Task<Unit> UpdateLastScan(Library library);
+    Task<Unit> UpdateLastScan(LibraryPath libraryPath);
+    Task<List<LibraryPath>> GetLocalPaths(int libraryId);
+    Task<Option<LibraryPath>> GetPath(int libraryPathId);
+    Task<int> CountMediaItemsByPath(int libraryPathId);
+    Task<List<int>> GetMediaIdsByLocalPath(int libraryPathId);
+    Task DeleteLocalPath(int libraryPathId);
+    Task<Unit> SetEtag(LibraryPath libraryPath, Option<LibraryFolder> knownFolder, string path, string etag);
+    Task<Unit> CleanEtagsForLibraryPath(LibraryPath libraryPath);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IMediaCollectionRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IMediaCollectionRepository.cs
index 2e182fc60..590ceac0d 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IMediaCollectionRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IMediaCollectionRepository.cs
@@ -1,23 +1,19 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IMediaCollectionRepository
 {
-    public interface IMediaCollectionRepository
-    {
-        Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id);
-        Task<List<MediaItem>> GetItems(int id);
-        Task<List<MediaItem>> GetMultiCollectionItems(int id);
-        Task<List<MediaItem>> GetSmartCollectionItems(int id);
-        Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id);
-        Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(int? collectionId, int? smartCollectionId);
-        Task<List<int>> PlayoutIdsUsingCollection(int collectionId);
-        Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId);
-        Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId);
-        Task<bool> IsCustomPlaybackOrder(int collectionId);
-        Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection);
-    }
-}
+    Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id);
+    Task<List<MediaItem>> GetItems(int id);
+    Task<List<MediaItem>> GetMultiCollectionItems(int id);
+    Task<List<MediaItem>> GetSmartCollectionItems(int id);
+    Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id);
+    Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(int? collectionId, int? smartCollectionId);
+    Task<List<int>> PlayoutIdsUsingCollection(int collectionId);
+    Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId);
+    Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId);
+    Task<bool> IsCustomPlaybackOrder(int collectionId);
+    Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IMediaItemRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IMediaItemRepository.cs
index ecce989e2..6d3635a18 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IMediaItemRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IMediaItemRepository.cs
@@ -1,15 +1,11 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IMediaItemRepository
 {
-    public interface IMediaItemRepository
-    {
-        Task<List<string>> GetAllLanguageCodes();
-        Task<List<int>> FlagFileNotFound(LibraryPath libraryPath, string path);
-        Task<Unit> FlagNormal(MediaItem mediaItem);
-        Task<Either<BaseError, Unit>> DeleteItems(List<int> mediaItemIds);
-    }
-}
+    Task<List<string>> GetAllLanguageCodes();
+    Task<List<int>> FlagFileNotFound(LibraryPath libraryPath, string path);
+    Task<Unit> FlagNormal(MediaItem mediaItem);
+    Task<Either<BaseError, Unit>> DeleteItems(List<int> mediaItemIds);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs
index 7a5bb4f95..a57224dc0 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IMediaSourceRepository.cs
@@ -1,88 +1,84 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IMediaSourceRepository
 {
-    public interface IMediaSourceRepository
-    {
-        Task<PlexMediaSource> Add(PlexMediaSource plexMediaSource);
-        Task<List<PlexMediaSource>> GetAllPlex();
-        Task<List<PlexLibrary>> GetPlexLibraries(int plexMediaSourceId);
-        Task<List<PlexPathReplacement>> GetPlexPathReplacements(int plexMediaSourceId);
-        Task<Option<PlexLibrary>> GetPlexLibrary(int plexLibraryId);
-        Task<Option<PlexMediaSource>> GetPlex(int id);
-        Task<Option<PlexMediaSource>> GetPlexByLibraryId(int plexLibraryId);
-        Task<List<PlexPathReplacement>> GetPlexPathReplacementsByLibraryId(int plexLibraryPathId);
+    Task<PlexMediaSource> Add(PlexMediaSource plexMediaSource);
+    Task<List<PlexMediaSource>> GetAllPlex();
+    Task<List<PlexLibrary>> GetPlexLibraries(int plexMediaSourceId);
+    Task<List<PlexPathReplacement>> GetPlexPathReplacements(int plexMediaSourceId);
+    Task<Option<PlexLibrary>> GetPlexLibrary(int plexLibraryId);
+    Task<Option<PlexMediaSource>> GetPlex(int id);
+    Task<Option<PlexMediaSource>> GetPlexByLibraryId(int plexLibraryId);
+    Task<List<PlexPathReplacement>> GetPlexPathReplacementsByLibraryId(int plexLibraryPathId);
 
-        Task Update(
-            PlexMediaSource plexMediaSource,
-            List<PlexConnection> toAdd,
-            List<PlexConnection> toDelete);
+    Task Update(
+        PlexMediaSource plexMediaSource,
+        List<PlexConnection> toAdd,
+        List<PlexConnection> toDelete);
 
-        Task<List<int>> UpdateLibraries(
-            int plexMediaSourceId,
-            List<PlexLibrary> toAdd,
-            List<PlexLibrary> toDelete);
+    Task<List<int>> UpdateLibraries(
+        int plexMediaSourceId,
+        List<PlexLibrary> toAdd,
+        List<PlexLibrary> toDelete);
 
-        Task<List<int>> UpdateLibraries(
-            int jellyfinMediaSourceId,
-            List<JellyfinLibrary> toAdd,
-            List<JellyfinLibrary> toDelete);
+    Task<List<int>> UpdateLibraries(
+        int jellyfinMediaSourceId,
+        List<JellyfinLibrary> toAdd,
+        List<JellyfinLibrary> toDelete);
 
-        Task<List<int>> UpdateLibraries(
-            int embyMediaSourceId,
-            List<EmbyLibrary> toAdd,
-            List<EmbyLibrary> toDelete);
+    Task<List<int>> UpdateLibraries(
+        int embyMediaSourceId,
+        List<EmbyLibrary> toAdd,
+        List<EmbyLibrary> toDelete);
 
-        Task<Unit> UpdatePathReplacements(
-            int plexMediaSourceId,
-            List<PlexPathReplacement> toAdd,
-            List<PlexPathReplacement> toUpdate,
-            List<PlexPathReplacement> toDelete);
+    Task<Unit> UpdatePathReplacements(
+        int plexMediaSourceId,
+        List<PlexPathReplacement> toAdd,
+        List<PlexPathReplacement> toUpdate,
+        List<PlexPathReplacement> toDelete);
 
-        Task<List<int>> DeleteAllPlex();
-        Task<List<int>> DeletePlex(PlexMediaSource plexMediaSource);
-        Task<List<int>> DisablePlexLibrarySync(List<int> libraryIds);
-        Task EnablePlexLibrarySync(IEnumerable<int> libraryIds);
+    Task<List<int>> DeleteAllPlex();
+    Task<List<int>> DeletePlex(PlexMediaSource plexMediaSource);
+    Task<List<int>> DisablePlexLibrarySync(List<int> libraryIds);
+    Task EnablePlexLibrarySync(IEnumerable<int> libraryIds);
 
-        Task<Unit> UpsertJellyfin(string address, string serverName, string operatingSystem);
-        Task<List<JellyfinMediaSource>> GetAllJellyfin();
-        Task<Option<JellyfinMediaSource>> GetJellyfin(int id);
-        Task<List<JellyfinLibrary>> GetJellyfinLibraries(int jellyfinMediaSourceId);
-        Task<Unit> EnableJellyfinLibrarySync(IEnumerable<int> libraryIds);
-        Task<List<int>> DisableJellyfinLibrarySync(List<int> libraryIds);
-        Task<Option<JellyfinLibrary>> GetJellyfinLibrary(int jellyfinLibraryId);
-        Task<Option<JellyfinMediaSource>> GetJellyfinByLibraryId(int jellyfinLibraryId);
-        Task<List<JellyfinPathReplacement>> GetJellyfinPathReplacements(int jellyfinMediaSourceId);
-        Task<List<JellyfinPathReplacement>> GetJellyfinPathReplacementsByLibraryId(int jellyfinLibraryPathId);
+    Task<Unit> UpsertJellyfin(string address, string serverName, string operatingSystem);
+    Task<List<JellyfinMediaSource>> GetAllJellyfin();
+    Task<Option<JellyfinMediaSource>> GetJellyfin(int id);
+    Task<List<JellyfinLibrary>> GetJellyfinLibraries(int jellyfinMediaSourceId);
+    Task<Unit> EnableJellyfinLibrarySync(IEnumerable<int> libraryIds);
+    Task<List<int>> DisableJellyfinLibrarySync(List<int> libraryIds);
+    Task<Option<JellyfinLibrary>> GetJellyfinLibrary(int jellyfinLibraryId);
+    Task<Option<JellyfinMediaSource>> GetJellyfinByLibraryId(int jellyfinLibraryId);
+    Task<List<JellyfinPathReplacement>> GetJellyfinPathReplacements(int jellyfinMediaSourceId);
+    Task<List<JellyfinPathReplacement>> GetJellyfinPathReplacementsByLibraryId(int jellyfinLibraryPathId);
 
-        Task<Unit> UpdatePathReplacements(
-            int jellyfinMediaSourceId,
-            List<JellyfinPathReplacement> toAdd,
-            List<JellyfinPathReplacement> toUpdate,
-            List<JellyfinPathReplacement> toDelete);
+    Task<Unit> UpdatePathReplacements(
+        int jellyfinMediaSourceId,
+        List<JellyfinPathReplacement> toAdd,
+        List<JellyfinPathReplacement> toUpdate,
+        List<JellyfinPathReplacement> toDelete);
 
-        Task<List<int>> DeleteAllJellyfin();
+    Task<List<int>> DeleteAllJellyfin();
 
-        Task<Unit> UpsertEmby(string address, string serverName, string operatingSystem);
-        Task<List<EmbyMediaSource>> GetAllEmby();
-        Task<Option<EmbyMediaSource>> GetEmby(int id);
-        Task<Option<EmbyMediaSource>> GetEmbyByLibraryId(int embyLibraryId);
-        Task<Option<EmbyLibrary>> GetEmbyLibrary(int embyLibraryId);
-        Task<List<EmbyLibrary>> GetEmbyLibraries(int embyMediaSourceId);
-        Task<List<EmbyPathReplacement>> GetEmbyPathReplacements(int embyMediaSourceId);
-        Task<List<EmbyPathReplacement>> GetEmbyPathReplacementsByLibraryId(int embyLibraryPathId);
+    Task<Unit> UpsertEmby(string address, string serverName, string operatingSystem);
+    Task<List<EmbyMediaSource>> GetAllEmby();
+    Task<Option<EmbyMediaSource>> GetEmby(int id);
+    Task<Option<EmbyMediaSource>> GetEmbyByLibraryId(int embyLibraryId);
+    Task<Option<EmbyLibrary>> GetEmbyLibrary(int embyLibraryId);
+    Task<List<EmbyLibrary>> GetEmbyLibraries(int embyMediaSourceId);
+    Task<List<EmbyPathReplacement>> GetEmbyPathReplacements(int embyMediaSourceId);
+    Task<List<EmbyPathReplacement>> GetEmbyPathReplacementsByLibraryId(int embyLibraryPathId);
 
-        Task<Unit> UpdatePathReplacements(
-            int embyMediaSourceId,
-            List<EmbyPathReplacement> toAdd,
-            List<EmbyPathReplacement> toUpdate,
-            List<EmbyPathReplacement> toDelete);
+    Task<Unit> UpdatePathReplacements(
+        int embyMediaSourceId,
+        List<EmbyPathReplacement> toAdd,
+        List<EmbyPathReplacement> toUpdate,
+        List<EmbyPathReplacement> toDelete);
 
-        Task<List<int>> DeleteAllEmby();
-        Task<Unit> EnableEmbyLibrarySync(IEnumerable<int> libraryIds);
-        Task<List<int>> DisableEmbyLibrarySync(List<int> libraryIds);
-    }
-}
+    Task<List<int>> DeleteAllEmby();
+    Task<Unit> EnableEmbyLibrarySync(IEnumerable<int> libraryIds);
+    Task<List<int>> DisableEmbyLibrarySync(List<int> libraryIds);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IMetadataRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IMetadataRepository.cs
index 8ae010412..5a4475ec8 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IMetadataRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IMetadataRepository.cs
@@ -1,42 +1,38 @@
-using System;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IMetadataRepository
 {
-    public interface IMetadataRepository
-    {
-        Task<bool> RemoveGenre(Genre genre);
-        Task<bool> RemoveTag(Tag tag);
-        Task<bool> RemoveStudio(Studio studio);
-        Task<bool> RemoveStyle(Style style);
-        Task<bool> RemoveMood(Mood mood);
-        Task<bool> RemoveActor(Actor actor);
-        Task<bool> Update(Domain.Metadata metadata);
-        Task<bool> Add(Domain.Metadata metadata);
-        Task<bool> UpdateLocalStatistics(MediaItem mediaItem, MediaVersion incoming, bool updateVersion = true);
-        Task<bool> UpdatePlexStatistics(int mediaVersionId, MediaVersion incoming);
-        Task<Unit> UpdateArtworkPath(Artwork artwork);
-        Task<Unit> AddArtwork(Domain.Metadata metadata, Artwork artwork);
-        Task<Unit> RemoveArtwork(Domain.Metadata metadata, ArtworkKind artworkKind);
-        Task<bool> CloneArtwork(
-            Domain.Metadata metadata,
-            Option<Artwork> maybeArtwork,
-            ArtworkKind artworkKind,
-            string sourcePath,
-            DateTime lastWriteTime);
-        Task<Unit> MarkAsUpdated(ShowMetadata metadata, DateTime dateUpdated);
-        Task<Unit> MarkAsUpdated(SeasonMetadata metadata, DateTime dateUpdated);
-        Task<Unit> MarkAsUpdated(MovieMetadata metadata, DateTime dateUpdated);
-        Task<Unit> MarkAsUpdated(EpisodeMetadata metadata, DateTime dateUpdated);
-        Task<Unit> MarkAsExternal(ShowMetadata metadata);
-        Task<Unit> SetContentRating(ShowMetadata metadata, string contentRating);
-        Task<Unit> MarkAsExternal(MovieMetadata metadata);
-        Task<Unit> SetContentRating(MovieMetadata metadata, string contentRating);
-        Task<bool> RemoveGuid(MetadataGuid guid);
-        Task<bool> AddGuid(Domain.Metadata metadata, MetadataGuid guid);
-        Task<bool> RemoveDirector(Director director);
-        Task<bool> RemoveWriter(Writer writer);
-    }
-}
+    Task<bool> RemoveGenre(Genre genre);
+    Task<bool> RemoveTag(Tag tag);
+    Task<bool> RemoveStudio(Studio studio);
+    Task<bool> RemoveStyle(Style style);
+    Task<bool> RemoveMood(Mood mood);
+    Task<bool> RemoveActor(Actor actor);
+    Task<bool> Update(Domain.Metadata metadata);
+    Task<bool> Add(Domain.Metadata metadata);
+    Task<bool> UpdateLocalStatistics(MediaItem mediaItem, MediaVersion incoming, bool updateVersion = true);
+    Task<bool> UpdatePlexStatistics(int mediaVersionId, MediaVersion incoming);
+    Task<Unit> UpdateArtworkPath(Artwork artwork);
+    Task<Unit> AddArtwork(Domain.Metadata metadata, Artwork artwork);
+    Task<Unit> RemoveArtwork(Domain.Metadata metadata, ArtworkKind artworkKind);
+    Task<bool> CloneArtwork(
+        Domain.Metadata metadata,
+        Option<Artwork> maybeArtwork,
+        ArtworkKind artworkKind,
+        string sourcePath,
+        DateTime lastWriteTime);
+    Task<Unit> MarkAsUpdated(ShowMetadata metadata, DateTime dateUpdated);
+    Task<Unit> MarkAsUpdated(SeasonMetadata metadata, DateTime dateUpdated);
+    Task<Unit> MarkAsUpdated(MovieMetadata metadata, DateTime dateUpdated);
+    Task<Unit> MarkAsUpdated(EpisodeMetadata metadata, DateTime dateUpdated);
+    Task<Unit> MarkAsExternal(ShowMetadata metadata);
+    Task<Unit> SetContentRating(ShowMetadata metadata, string contentRating);
+    Task<Unit> MarkAsExternal(MovieMetadata metadata);
+    Task<Unit> SetContentRating(MovieMetadata metadata, string contentRating);
+    Task<bool> RemoveGuid(MetadataGuid guid);
+    Task<bool> AddGuid(Domain.Metadata metadata, MetadataGuid guid);
+    Task<bool> RemoveDirector(Director director);
+    Task<bool> RemoveWriter(Writer writer);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IMovieRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IMovieRepository.cs
index b832299c7..6b3eb56c3 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IMovieRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IMovieRepository.cs
@@ -1,38 +1,34 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Jellyfin;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IMovieRepository
 {
-    public interface IMovieRepository
-    {
-        Task<bool> AllMoviesExist(List<int> movieIds);
-        Task<Option<Movie>> GetMovie(int movieId);
-        Task<Either<BaseError, MediaItemScanResult<Movie>>> GetOrAdd(LibraryPath libraryPath, string path);
-        Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> GetOrAdd(PlexLibrary library, PlexMovie item);
-        Task<List<MovieMetadata>> GetMoviesForCards(List<int> ids);
-        Task<IEnumerable<string>> FindMoviePaths(LibraryPath libraryPath);
-        Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
-        Task<bool> AddGenre(MovieMetadata metadata, Genre genre);
-        Task<bool> AddTag(MovieMetadata metadata, Tag tag);
-        Task<bool> AddStudio(MovieMetadata metadata, Studio studio);
-        Task<bool> AddActor(MovieMetadata metadata, Actor actor);
-        Task<List<int>> RemoveMissingPlexMovies(PlexLibrary library, List<string> movieKeys);
-        Task<bool> UpdateSortTitle(MovieMetadata movieMetadata);
-        Task<List<JellyfinItemEtag>> GetExistingJellyfinMovies(JellyfinLibrary library);
-        Task<List<int>> RemoveMissingJellyfinMovies(JellyfinLibrary library, List<string> movieIds);
-        Task<bool> AddJellyfin(JellyfinMovie movie);
-        Task<Option<JellyfinMovie>> UpdateJellyfin(JellyfinMovie movie);
-        Task<List<EmbyItemEtag>> GetExistingEmbyMovies(EmbyLibrary library);
-        Task<List<int>> RemoveMissingEmbyMovies(EmbyLibrary library, List<string> movieIds);
-        Task<bool> AddEmby(EmbyMovie movie);
-        Task<Option<EmbyMovie>> UpdateEmby(EmbyMovie movie);
-        Task<bool> AddDirector(MovieMetadata metadata, Director director);
-        Task<bool> AddWriter(MovieMetadata metadata, Writer writer);
-        Task<Unit> UpdatePath(int mediaFileId, string path);
-    }
-}
+    Task<bool> AllMoviesExist(List<int> movieIds);
+    Task<Option<Movie>> GetMovie(int movieId);
+    Task<Either<BaseError, MediaItemScanResult<Movie>>> GetOrAdd(LibraryPath libraryPath, string path);
+    Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> GetOrAdd(PlexLibrary library, PlexMovie item);
+    Task<List<MovieMetadata>> GetMoviesForCards(List<int> ids);
+    Task<IEnumerable<string>> FindMoviePaths(LibraryPath libraryPath);
+    Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
+    Task<bool> AddGenre(MovieMetadata metadata, Genre genre);
+    Task<bool> AddTag(MovieMetadata metadata, Tag tag);
+    Task<bool> AddStudio(MovieMetadata metadata, Studio studio);
+    Task<bool> AddActor(MovieMetadata metadata, Actor actor);
+    Task<List<int>> RemoveMissingPlexMovies(PlexLibrary library, List<string> movieKeys);
+    Task<bool> UpdateSortTitle(MovieMetadata movieMetadata);
+    Task<List<JellyfinItemEtag>> GetExistingJellyfinMovies(JellyfinLibrary library);
+    Task<List<int>> RemoveMissingJellyfinMovies(JellyfinLibrary library, List<string> movieIds);
+    Task<bool> AddJellyfin(JellyfinMovie movie);
+    Task<Option<JellyfinMovie>> UpdateJellyfin(JellyfinMovie movie);
+    Task<List<EmbyItemEtag>> GetExistingEmbyMovies(EmbyLibrary library);
+    Task<List<int>> RemoveMissingEmbyMovies(EmbyLibrary library, List<string> movieIds);
+    Task<bool> AddEmby(EmbyMovie movie);
+    Task<Option<EmbyMovie>> UpdateEmby(EmbyMovie movie);
+    Task<bool> AddDirector(MovieMetadata metadata, Director director);
+    Task<bool> AddWriter(MovieMetadata metadata, Writer writer);
+    Task<Unit> UpdatePath(int mediaFileId, string path);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IMusicVideoRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IMusicVideoRepository.cs
index 918bfc73b..6e6001049 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IMusicVideoRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IMusicVideoRepository.cs
@@ -1,26 +1,22 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IMusicVideoRepository
 {
-    public interface IMusicVideoRepository
-    {
-        Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> GetOrAdd(
-            Artist artist,
-            LibraryPath libraryPath,
-            string path);
+    Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> GetOrAdd(
+        Artist artist,
+        LibraryPath libraryPath,
+        string path);
 
-        Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath);
-        Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
-        Task<bool> AddGenre(MusicVideoMetadata metadata, Genre genre);
-        Task<bool> AddTag(MusicVideoMetadata metadata, Tag tag);
-        Task<bool> AddStudio(MusicVideoMetadata metadata, Studio studio);
-        Task<List<MusicVideoMetadata>> GetMusicVideosForCards(List<int> ids);
-        Task<IEnumerable<string>> FindOrphanPaths(LibraryPath libraryPath);
-        Task<int> GetMusicVideoCount(int artistId);
-        Task<List<MusicVideoMetadata>> GetPagedMusicVideos(int artistId, int pageNumber, int pageSize);
-    }
-}
+    Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath);
+    Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
+    Task<bool> AddGenre(MusicVideoMetadata metadata, Genre genre);
+    Task<bool> AddTag(MusicVideoMetadata metadata, Tag tag);
+    Task<bool> AddStudio(MusicVideoMetadata metadata, Studio studio);
+    Task<List<MusicVideoMetadata>> GetMusicVideosForCards(List<int> ids);
+    Task<IEnumerable<string>> FindOrphanPaths(LibraryPath libraryPath);
+    Task<int> GetMusicVideoCount(int artistId);
+    Task<List<MusicVideoMetadata>> GetPagedMusicVideos(int artistId, int pageNumber, int pageSize);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/IOtherVideoRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/IOtherVideoRepository.cs
index 61fda9390..fa1f765f1 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/IOtherVideoRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/IOtherVideoRepository.cs
@@ -1,19 +1,15 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface IOtherVideoRepository
 {
-    public interface IOtherVideoRepository
-    {
-        Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> GetOrAdd(LibraryPath libraryPath, string path);
-        Task<IEnumerable<string>> FindOtherVideoPaths(LibraryPath libraryPath);
-        Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
-        Task<bool> AddTag(OtherVideoMetadata metadata, Tag tag);
-        Task<List<OtherVideoMetadata>> GetOtherVideosForCards(List<int> ids);
-        // Task<int> GetOtherVideoCount(int artistId);
-        // Task<List<OtherVideoMetadata>> GetPagedOtherVideos(int artistId, int pageNumber, int pageSize);
-    }
-}
+    Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> GetOrAdd(LibraryPath libraryPath, string path);
+    Task<IEnumerable<string>> FindOtherVideoPaths(LibraryPath libraryPath);
+    Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
+    Task<bool> AddTag(OtherVideoMetadata metadata, Tag tag);
+    Task<List<OtherVideoMetadata>> GetOtherVideosForCards(List<int> ids);
+    // Task<int> GetOtherVideoCount(int artistId);
+    // Task<List<OtherVideoMetadata>> GetPagedOtherVideos(int artistId, int pageNumber, int pageSize);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/ISearchRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/ISearchRepository.cs
index 92d36c7c7..3d7a27327 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/ISearchRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/ISearchRepository.cs
@@ -1,17 +1,13 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface ISearchRepository
 {
-    public interface ISearchRepository
-    {
-        Task<List<int>> GetItemIdsToIndex();
-        Task<Option<MediaItem>> GetItemToIndex(int id);
-        Task<List<string>> GetLanguagesForShow(Show show);
-        Task<List<string>> GetLanguagesForSeason(Season season);
-        Task<List<string>> GetLanguagesForArtist(Artist artist);
-        Task<List<string>> GetAllLanguageCodes(List<string> mediaCodes);
-    }
-}
+    Task<List<int>> GetItemIdsToIndex();
+    Task<Option<MediaItem>> GetItemToIndex(int id);
+    Task<List<string>> GetLanguagesForShow(Show show);
+    Task<List<string>> GetLanguagesForSeason(Season season);
+    Task<List<string>> GetLanguagesForArtist(Artist artist);
+    Task<List<string>> GetAllLanguageCodes(List<string> mediaCodes);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/ISongRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/ISongRepository.cs
index 0a3f320de..f8fa503ef 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/ISongRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/ISongRepository.cs
@@ -1,18 +1,14 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface ISongRepository
 {
-    public interface ISongRepository
-    {
-        Task<Either<BaseError, MediaItemScanResult<Song>>> GetOrAdd(LibraryPath libraryPath, string path);
-        Task<IEnumerable<string>> FindSongPaths(LibraryPath libraryPath);
-        Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
-        Task<bool> AddGenre(SongMetadata metadata, Genre genre);
-        Task<bool> AddTag(SongMetadata metadata, Tag tag);
-        Task<List<SongMetadata>> GetSongsForCards(List<int> ids);
-    }
-}
+    Task<Either<BaseError, MediaItemScanResult<Song>>> GetOrAdd(LibraryPath libraryPath, string path);
+    Task<IEnumerable<string>> FindSongPaths(LibraryPath libraryPath);
+    Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path);
+    Task<bool> AddGenre(SongMetadata metadata, Genre genre);
+    Task<bool> AddTag(SongMetadata metadata, Tag tag);
+    Task<List<SongMetadata>> GetSongsForCards(List<int> ids);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Repositories/ITelevisionRepository.cs b/ErsatzTV.Core/Interfaces/Repositories/ITelevisionRepository.cs
index 0774c4888..7c82c82d5 100644
--- a/ErsatzTV.Core/Interfaces/Repositories/ITelevisionRepository.cs
+++ b/ErsatzTV.Core/Interfaces/Repositories/ITelevisionRepository.cs
@@ -1,56 +1,52 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Repositories
+namespace ErsatzTV.Core.Interfaces.Repositories;
+
+public interface ITelevisionRepository
 {
-    public interface ITelevisionRepository
-    {
-        Task<bool> AllShowsExist(List<int> showIds);
-        Task<bool> AllSeasonsExist(List<int> seasonIds);
-        Task<bool> AllEpisodesExist(List<int> episodeIds);
-        Task<List<Show>> GetAllShows();
-        Task<Option<Show>> GetShow(int showId);
-        Task<List<ShowMetadata>> GetShowsForCards(List<int> ids);
-        Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids);
-        Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids);
-        Task<List<Episode>> GetShowItems(int showId);
-        Task<List<Season>> GetAllSeasons();
-        Task<Option<Season>> GetSeason(int seasonId);
-        Task<int> GetSeasonCount(int showId);
-        Task<List<Season>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize);
-        Task<List<Episode>> GetSeasonItems(int seasonId);
-        Task<int> GetEpisodeCount(int seasonId);
-        Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize);
-        Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata);
+    Task<bool> AllShowsExist(List<int> showIds);
+    Task<bool> AllSeasonsExist(List<int> seasonIds);
+    Task<bool> AllEpisodesExist(List<int> episodeIds);
+    Task<List<Show>> GetAllShows();
+    Task<Option<Show>> GetShow(int showId);
+    Task<List<ShowMetadata>> GetShowsForCards(List<int> ids);
+    Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids);
+    Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids);
+    Task<List<Episode>> GetShowItems(int showId);
+    Task<List<Season>> GetAllSeasons();
+    Task<Option<Season>> GetSeason(int seasonId);
+    Task<int> GetSeasonCount(int showId);
+    Task<List<Season>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize);
+    Task<List<Episode>> GetSeasonItems(int seasonId);
+    Task<int> GetEpisodeCount(int seasonId);
+    Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize);
+    Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata);
 
-        Task<Either<BaseError, MediaItemScanResult<Show>>> AddShow(
-            int libraryPathId,
-            string showFolder,
-            ShowMetadata metadata);
+    Task<Either<BaseError, MediaItemScanResult<Show>>> AddShow(
+        int libraryPathId,
+        string showFolder,
+        ShowMetadata metadata);
 
-        Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber);
-        Task<Either<BaseError, Episode>> GetOrAddEpisode(Season season, LibraryPath libraryPath, string path);
-        Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath);
-        Task<Unit> DeleteByPath(LibraryPath libraryPath, string path);
-        Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath);
-        Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath);
-        Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(PlexLibrary library, PlexShow item);
-        Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item);
-        Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item);
-        Task<bool> AddGenre(ShowMetadata metadata, Genre genre);
-        Task<bool> AddTag(ShowMetadata metadata, Tag tag);
-        Task<bool> AddStudio(ShowMetadata metadata, Studio studio);
-        Task<bool> AddActor(ShowMetadata metadata, Actor actor);
-        Task<bool> AddActor(EpisodeMetadata metadata, Actor actor);
-        Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys);
-        Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys);
-        Task<List<int>> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys);
-        Task<Unit> RemoveMetadata(Episode episode, EpisodeMetadata metadata);
-        Task<bool> AddDirector(EpisodeMetadata metadata, Director director);
-        Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer);
-        Task<Unit> UpdatePath(int mediaFileId, string path);
-    }
-}
+    Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber);
+    Task<Either<BaseError, Episode>> GetOrAddEpisode(Season season, LibraryPath libraryPath, string path);
+    Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath);
+    Task<Unit> DeleteByPath(LibraryPath libraryPath, string path);
+    Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath);
+    Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath);
+    Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(PlexLibrary library, PlexShow item);
+    Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item);
+    Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item);
+    Task<bool> AddGenre(ShowMetadata metadata, Genre genre);
+    Task<bool> AddTag(ShowMetadata metadata, Tag tag);
+    Task<bool> AddStudio(ShowMetadata metadata, Studio studio);
+    Task<bool> AddActor(ShowMetadata metadata, Actor actor);
+    Task<bool> AddActor(EpisodeMetadata metadata, Actor actor);
+    Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys);
+    Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys);
+    Task<List<int>> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys);
+    Task<Unit> RemoveMetadata(Episode episode, EpisodeMetadata metadata);
+    Task<bool> AddDirector(EpisodeMetadata metadata, Director director);
+    Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer);
+    Task<Unit> UpdatePath(int mediaFileId, string path);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Runtime/IRuntimeInfo.cs b/ErsatzTV.Core/Interfaces/Runtime/IRuntimeInfo.cs
index 1f255cc20..0bffce7a8 100644
--- a/ErsatzTV.Core/Interfaces/Runtime/IRuntimeInfo.cs
+++ b/ErsatzTV.Core/Interfaces/Runtime/IRuntimeInfo.cs
@@ -1,11 +1,10 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 
-namespace ErsatzTV.Core.Interfaces.Runtime
+namespace ErsatzTV.Core.Interfaces.Runtime;
+
+public interface IRuntimeInfo
 {
-    public interface IRuntimeInfo
-    {
-        [SuppressMessage("ReSharper", "InconsistentNaming")]
-        bool IsOSPlatform(OSPlatform osPlatform);
-    }
-}
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    bool IsOSPlatform(OSPlatform osPlatform);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Scheduling/IMediaCollectionEnumerator.cs b/ErsatzTV.Core/Interfaces/Scheduling/IMediaCollectionEnumerator.cs
index fbc62d797..ff010fc9a 100644
--- a/ErsatzTV.Core/Interfaces/Scheduling/IMediaCollectionEnumerator.cs
+++ b/ErsatzTV.Core/Interfaces/Scheduling/IMediaCollectionEnumerator.cs
@@ -1,13 +1,11 @@
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Scheduling
+namespace ErsatzTV.Core.Interfaces.Scheduling;
+
+public interface IMediaCollectionEnumerator
 {
-    public interface IMediaCollectionEnumerator
-    {
-        CollectionEnumeratorState State { get; }
-        Option<MediaItem> Current { get; }
-        void MoveNext();
-        Option<MediaItem> Peek(int offset);
-    }
-}
+    CollectionEnumeratorState State { get; }
+    Option<MediaItem> Current { get; }
+    void MoveNext();
+    Option<MediaItem> Peek(int offset);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Scheduling/IPlayoutBuilder.cs b/ErsatzTV.Core/Interfaces/Scheduling/IPlayoutBuilder.cs
index 6e8224bbe..ed6112eaa 100644
--- a/ErsatzTV.Core/Interfaces/Scheduling/IPlayoutBuilder.cs
+++ b/ErsatzTV.Core/Interfaces/Scheduling/IPlayoutBuilder.cs
@@ -1,17 +1,14 @@
-using System;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Interfaces.Scheduling
+namespace ErsatzTV.Core.Interfaces.Scheduling;
+
+public interface IPlayoutBuilder
 {
-    public interface IPlayoutBuilder
-    {
-        Task<Playout> BuildPlayoutItems(Playout playout, bool rebuild = false);
+    Task<Playout> BuildPlayoutItems(Playout playout, bool rebuild = false);
 
-        Task<Playout> BuildPlayoutItems(
-            Playout playout,
-            DateTimeOffset playoutStart,
-            DateTimeOffset playoutFinish,
-            bool rebuild = false);
-    }
-}
+    Task<Playout> BuildPlayoutItems(
+        Playout playout,
+        DateTimeOffset playoutStart,
+        DateTimeOffset playoutFinish,
+        bool rebuild = false);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Scheduling/IPlayoutModeScheduler.cs b/ErsatzTV.Core/Interfaces/Scheduling/IPlayoutModeScheduler.cs
index 40df01df0..ae31fed14 100644
--- a/ErsatzTV.Core/Interfaces/Scheduling/IPlayoutModeScheduler.cs
+++ b/ErsatzTV.Core/Interfaces/Scheduling/IPlayoutModeScheduler.cs
@@ -1,17 +1,14 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 
-namespace ErsatzTV.Core.Interfaces.Scheduling
+namespace ErsatzTV.Core.Interfaces.Scheduling;
+
+public interface IPlayoutModeScheduler<in T> where T : ProgramScheduleItem
 {
-    public interface IPlayoutModeScheduler<in T> where T : ProgramScheduleItem
-    {
-        Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
-            T scheduleItem,
-            ProgramScheduleItem nextScheduleItem,
-            DateTimeOffset hardStop);
-    }
-}
+    Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+        T scheduleItem,
+        ProgramScheduleItem nextScheduleItem,
+        DateTimeOffset hardStop);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Scheduling/IScheduleItemsEnumerator.cs b/ErsatzTV.Core/Interfaces/Scheduling/IScheduleItemsEnumerator.cs
index ee3dd6992..ae68dd60b 100644
--- a/ErsatzTV.Core/Interfaces/Scheduling/IScheduleItemsEnumerator.cs
+++ b/ErsatzTV.Core/Interfaces/Scheduling/IScheduleItemsEnumerator.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 
 namespace ErsatzTV.Core.Interfaces.Scheduling;
 
diff --git a/ErsatzTV.Core/Interfaces/Search/ISearchIndex.cs b/ErsatzTV.Core/Interfaces/Search/ISearchIndex.cs
index 2aa5ac1d0..4df8dc2a1 100644
--- a/ErsatzTV.Core/Interfaces/Search/ISearchIndex.cs
+++ b/ErsatzTV.Core/Interfaces/Search/ISearchIndex.cs
@@ -1,24 +1,19 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Search;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Search
+namespace ErsatzTV.Core.Interfaces.Search;
+
+public interface ISearchIndex : IDisposable
 {
-    public interface ISearchIndex : IDisposable
-    {
-        public int Version { get; }
-        Task<bool> Initialize(ILocalFileSystem localFileSystem);
-        Task<Unit> Rebuild(ISearchRepository searchRepository, List<int> itemIds);
-        Task<Unit> RebuildItems(ISearchRepository searchRepository, List<int> itemIds);
-        Task<Unit> AddItems(ISearchRepository searchRepository, List<MediaItem> items);
-        Task<Unit> UpdateItems(ISearchRepository searchRepository, List<MediaItem> items);
-        Task<Unit> RemoveItems(List<int> ids);
-        Task<SearchResult> Search(string query, int skip, int limit, string searchField = "");
-        void Commit();
-    }
-}
+    public int Version { get; }
+    Task<bool> Initialize(ILocalFileSystem localFileSystem);
+    Task<Unit> Rebuild(ISearchRepository searchRepository, List<int> itemIds);
+    Task<Unit> RebuildItems(ISearchRepository searchRepository, List<int> itemIds);
+    Task<Unit> AddItems(ISearchRepository searchRepository, List<MediaItem> items);
+    Task<Unit> UpdateItems(ISearchRepository searchRepository, List<MediaItem> items);
+    Task<Unit> RemoveItems(List<int> ids);
+    Task<SearchResult> Search(string query, int skip, int limit, string searchField = "");
+    void Commit();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Interfaces/Trakt/ITraktApiClient.cs b/ErsatzTV.Core/Interfaces/Trakt/ITraktApiClient.cs
index 57f5579c6..8d1f2a8c1 100644
--- a/ErsatzTV.Core/Interfaces/Trakt/ITraktApiClient.cs
+++ b/ErsatzTV.Core/Interfaces/Trakt/ITraktApiClient.cs
@@ -1,14 +1,10 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Trakt;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Interfaces.Trakt
+namespace ErsatzTV.Core.Interfaces.Trakt;
+
+public interface ITraktApiClient
 {
-    public interface ITraktApiClient
-    {
-        Task<Either<BaseError, TraktList>> GetUserList(string user, string list);
-        Task<Either<BaseError, List<TraktListItemWithGuids>>> GetUserListItems(string user, string list);
-    }
-}
+    Task<Either<BaseError, TraktList>> GetUserList(string user, string list);
+    Task<Either<BaseError, List<TraktListItemWithGuids>>> GetUserListItems(string user, string list);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Iptv/ChannelGuide.cs b/ErsatzTV.Core/Iptv/ChannelGuide.cs
index 6b317a4fc..5e3e707c1 100644
--- a/ErsatzTV.Core/Iptv/ChannelGuide.cs
+++ b/ErsatzTV.Core/Iptv/ChannelGuide.cs
@@ -1,511 +1,504 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
+using System.Text;
 using System.Xml;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 using Serilog;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Iptv
+namespace ErsatzTV.Core.Iptv;
+
+public class ChannelGuide
 {
-    public class ChannelGuide
-    {
-        private readonly List<Channel> _channels;
-        private readonly string _host;
-        private readonly string _scheme;
+    private readonly List<Channel> _channels;
+    private readonly string _host;
+    private readonly string _scheme;
 
-        public ChannelGuide(string scheme, string host, List<Channel> channels)
+    public ChannelGuide(string scheme, string host, List<Channel> channels)
+    {
+        _scheme = scheme;
+        _host = host;
+        _channels = channels;
+    }
+
+    public string ToXml()
+    {
+        using var ms = new MemoryStream();
+        using var xml = XmlWriter.Create(ms);
+        xml.WriteStartDocument();
+
+        xml.WriteStartElement("tv");
+        xml.WriteAttributeString("generator-info-name", "ersatztv");
+
+        var sortedChannelItems = new Dictionary<Channel, List<PlayoutItem>>();
+
+        foreach (Channel channel in _channels.OrderBy(c => decimal.Parse(c.Number)))
         {
-            _scheme = scheme;
-            _host = host;
-            _channels = channels;
+            var sortedItems = channel.Playouts.Collect(p => p.Items).OrderBy(x => x.Start).ToList();
+            sortedChannelItems.Add(channel, sortedItems);
+
+            if (sortedItems.Any())
+            {
+                xml.WriteStartElement("channel");
+                xml.WriteAttributeString("id", $"{channel.Number}.etv");
+
+                xml.WriteStartElement("display-name");
+                xml.WriteAttributeString("lang", "en");
+                xml.WriteString(channel.Name);
+                xml.WriteEndElement(); // display-name
+
+                foreach (string category in GetCategories(channel.Categories))
+                {
+                    xml.WriteStartElement("category");
+                    xml.WriteAttributeString("lang", "en");
+                    xml.WriteString(category);
+                    xml.WriteEndElement(); // category
+                }
+
+                xml.WriteStartElement("icon");
+                string logo = Optional(channel.Artwork).Flatten()
+                    .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
+                    .HeadOrNone()
+                    .Match(
+                        artwork => $"{_scheme}://{_host}/iptv/logos/{artwork.Path}.jpg",
+                        () => $"{_scheme}://{_host}/iptv/images/ersatztv-500.png");
+                xml.WriteAttributeString("src", logo);
+                xml.WriteEndElement(); // icon
+
+                xml.WriteEndElement(); // channel
+            }
         }
 
-        public string ToXml()
+        foreach ((Channel channel, List<PlayoutItem> sorted) in sortedChannelItems.OrderBy(kvp => kvp.Key.Number))
         {
-            using var ms = new MemoryStream();
-            using var xml = XmlWriter.Create(ms);
-            xml.WriteStartDocument();
-
-            xml.WriteStartElement("tv");
-            xml.WriteAttributeString("generator-info-name", "ersatztv");
-
-            var sortedChannelItems = new Dictionary<Channel, List<PlayoutItem>>();
-
-            foreach (Channel channel in _channels.OrderBy(c => decimal.Parse(c.Number)))
+            var i = 0;
+            while (i < sorted.Count && sorted[i].FillerKind != FillerKind.None && sorted[i].FillerKind != FillerKind.PreRoll)
             {
-                var sortedItems = channel.Playouts.Collect(p => p.Items).OrderBy(x => x.Start).ToList();
-                sortedChannelItems.Add(channel, sortedItems);
-
-                if (sortedItems.Any())
-                {
-                    xml.WriteStartElement("channel");
-                    xml.WriteAttributeString("id", $"{channel.Number}.etv");
-
-                    xml.WriteStartElement("display-name");
-                    xml.WriteAttributeString("lang", "en");
-                    xml.WriteString(channel.Name);
-                    xml.WriteEndElement(); // display-name
-
-                    foreach (string category in GetCategories(channel.Categories))
-                    {
-                        xml.WriteStartElement("category");
-                        xml.WriteAttributeString("lang", "en");
-                        xml.WriteString(category);
-                        xml.WriteEndElement(); // category
-                    }
-
-                    xml.WriteStartElement("icon");
-                    string logo = Optional(channel.Artwork).Flatten()
-                        .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
-                        .HeadOrNone()
-                        .Match(
-                            artwork => $"{_scheme}://{_host}/iptv/logos/{artwork.Path}.jpg",
-                            () => $"{_scheme}://{_host}/iptv/images/ersatztv-500.png");
-                    xml.WriteAttributeString("src", logo);
-                    xml.WriteEndElement(); // icon
-
-                    xml.WriteEndElement(); // channel
-                }
+                i++;
             }
 
-            foreach ((Channel channel, List<PlayoutItem> sorted) in sortedChannelItems.OrderBy(kvp => kvp.Key.Number))
+            while (i < sorted.Count)
             {
-                var i = 0;
-                while (i < sorted.Count && sorted[i].FillerKind != FillerKind.None && sorted[i].FillerKind != FillerKind.PreRoll)
+                PlayoutItem startItem = sorted[i];
+                int j = i;
+                while (j + 1 < sorted.Count && sorted[j].FillerKind != FillerKind.None)
                 {
-                    i++;
+                    j++;
+                }
+                PlayoutItem displayItem = sorted[j];
+                bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
+
+                int finishIndex = i;
+                while (finishIndex + 1 < sorted.Count && sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup)
+                {
+                    finishIndex++;
                 }
 
-                while (i < sorted.Count)
+                int customShowId = -1;
+                if (displayItem.MediaItem is Episode ep)
                 {
-                    PlayoutItem startItem = sorted[i];
-                    int j = i;
-                    while (j + 1 < sorted.Count && sorted[j].FillerKind != FillerKind.None)
-                    {
-                        j++;
-                    }
-                    PlayoutItem displayItem = sorted[j];
-                    bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
+                    customShowId = ep.Season.ShowId;
+                }
 
-                    int finishIndex = i;
-                    while (finishIndex + 1 < sorted.Count && sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup)
-                    {
-                        finishIndex++;
-                    }
+                bool isSameCustomShow = hasCustomTitle;
+                for (int x = j; x <= finishIndex; x++)
+                {
+                    isSameCustomShow = isSameCustomShow && sorted[x].MediaItem is Episode e &&
+                                       customShowId == e.Season.ShowId;
+                }
 
-                    int customShowId = -1;
-                    if (displayItem.MediaItem is Episode ep)
-                    {
-                        customShowId = ep.Season.ShowId;
-                    }
+                PlayoutItem finishItem = sorted[finishIndex];
+                i = finishIndex;
 
-                    bool isSameCustomShow = hasCustomTitle;
-                    for (int x = j; x <= finishIndex; x++)
-                    {
-                        isSameCustomShow = isSameCustomShow && sorted[x].MediaItem is Episode e &&
-                                           customShowId == e.Season.ShowId;
-                    }
+                string start = startItem.StartOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
+                string stop = displayItem.GuideFinishOffset.HasValue
+                    ? displayItem.GuideFinishOffset.Value.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty)
+                    : finishItem.FinishOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
 
-                    PlayoutItem finishItem = sorted[finishIndex];
-                    i = finishIndex;
+                string title = GetTitle(displayItem);
+                string subtitle = GetSubtitle(displayItem);
+                string description = GetDescription(displayItem);
+                Option<ContentRating> contentRating = GetContentRating(displayItem);
 
-                    string start = startItem.StartOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
-                    string stop = displayItem.GuideFinishOffset.HasValue
-                        ? displayItem.GuideFinishOffset.Value.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty)
-                        : finishItem.FinishOffset.ToString("yyyyMMddHHmmss zzz").Replace(":", string.Empty);
-
-                    string title = GetTitle(displayItem);
-                    string subtitle = GetSubtitle(displayItem);
-                    string description = GetDescription(displayItem);
-                    Option<ContentRating> contentRating = GetContentRating(displayItem);
-
-                    xml.WriteStartElement("programme");
-                    xml.WriteAttributeString("start", start);
-                    xml.WriteAttributeString("stop", stop);
-                    xml.WriteAttributeString("channel", $"{channel.Number}.etv");
+                xml.WriteStartElement("programme");
+                xml.WriteAttributeString("start", start);
+                xml.WriteAttributeString("stop", stop);
+                xml.WriteAttributeString("channel", $"{channel.Number}.etv");
                     
-                    xml.WriteStartElement("title");
+                xml.WriteStartElement("title");
+                xml.WriteAttributeString("lang", "en");
+                xml.WriteString(title);
+                xml.WriteEndElement(); // title
+
+                if (!string.IsNullOrWhiteSpace(subtitle))
+                {
+                    xml.WriteStartElement("sub-title");
                     xml.WriteAttributeString("lang", "en");
-                    xml.WriteString(title);
-                    xml.WriteEndElement(); // title
-
-                    if (!string.IsNullOrWhiteSpace(subtitle))
-                    {
-                        xml.WriteStartElement("sub-title");
-                        xml.WriteAttributeString("lang", "en");
-                        xml.WriteString(subtitle);
-                        xml.WriteEndElement(); // subtitle
-                    }
+                    xml.WriteString(subtitle);
+                    xml.WriteEndElement(); // subtitle
+                }
                     
-                    if (!isSameCustomShow)
+                if (!isSameCustomShow)
+                {
+                    if (!string.IsNullOrWhiteSpace(description))
                     {
-                        if (!string.IsNullOrWhiteSpace(description))
-                        {
-                            xml.WriteStartElement("desc");
-                            xml.WriteAttributeString("lang", "en");
-                            xml.WriteString(description);
-                            xml.WriteEndElement(); // desc
-                        }
+                        xml.WriteStartElement("desc");
+                        xml.WriteAttributeString("lang", "en");
+                        xml.WriteString(description);
+                        xml.WriteEndElement(); // desc
                     }
+                }
 
-                    if (!hasCustomTitle && displayItem.MediaItem is Movie movie)
+                if (!hasCustomTitle && displayItem.MediaItem is Movie movie)
+                {
+                    foreach (MovieMetadata metadata in movie.MovieMetadata.HeadOrNone())
                     {
-                        foreach (MovieMetadata metadata in movie.MovieMetadata.HeadOrNone())
+                        if (metadata.Year.HasValue)
                         {
-                            if (metadata.Year.HasValue)
-                            {
-                                xml.WriteStartElement("date");
-                                xml.WriteString(metadata.Year.Value.ToString());
-                                xml.WriteEndElement(); // date
-                            }
+                            xml.WriteStartElement("date");
+                            xml.WriteString(metadata.Year.Value.ToString());
+                            xml.WriteEndElement(); // date
+                        }
 
+                        xml.WriteStartElement("category");
+                        xml.WriteAttributeString("lang", "en");
+                        xml.WriteString("Movie");
+                        xml.WriteEndElement(); // category
+
+                        foreach (Genre genre in Optional(metadata.Genres).Flatten())
+                        {
                             xml.WriteStartElement("category");
                             xml.WriteAttributeString("lang", "en");
-                            xml.WriteString("Movie");
+                            xml.WriteString(genre.Name);
                             xml.WriteEndElement(); // category
-
-                            foreach (Genre genre in Optional(metadata.Genres).Flatten())
-                            {
-                                xml.WriteStartElement("category");
-                                xml.WriteAttributeString("lang", "en");
-                                xml.WriteString(genre.Name);
-                                xml.WriteEndElement(); // category
-                            }
-
-                            string poster = Optional(metadata.Artwork).Flatten()
-                                .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
-                                .HeadOrNone()
-                                .Match(a => GetArtworkUrl(a, ArtworkKind.Poster), () => string.Empty);
-
-                            if (!string.IsNullOrWhiteSpace(poster))
-                            {
-                                xml.WriteStartElement("icon");
-                                xml.WriteAttributeString("src", poster);
-                                xml.WriteEndElement(); // icon
-                            }
                         }
-                    }
 
-                    if (!hasCustomTitle && displayItem.MediaItem is MusicVideo musicVideo)
-                    {
-                        foreach (MusicVideoMetadata metadata in musicVideo.MusicVideoMetadata.HeadOrNone())
+                        string poster = Optional(metadata.Artwork).Flatten()
+                            .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
+                            .HeadOrNone()
+                            .Match(a => GetArtworkUrl(a, ArtworkKind.Poster), () => string.Empty);
+
+                        if (!string.IsNullOrWhiteSpace(poster))
                         {
-                            if (metadata.Year.HasValue)
-                            {
-                                xml.WriteStartElement("date");
-                                xml.WriteString(metadata.Year.Value.ToString());
-                                xml.WriteEndElement(); // date
-                            }
-
-                            xml.WriteStartElement("category");
-                            xml.WriteAttributeString("lang", "en");
-                            xml.WriteString("Music");
-                            xml.WriteEndElement(); // category
-
-                            // music video genres
-                            foreach (Genre genre in Optional(metadata.Genres).Flatten())
-                            {
-                                xml.WriteStartElement("category");
-                                xml.WriteAttributeString("lang", "en");
-                                xml.WriteString(genre.Name);
-                                xml.WriteEndElement(); // category
-                            }
-
-                            // artist genres
-                            Option<ArtistMetadata> maybeMetadata =
-                                Optional(musicVideo.Artist?.ArtistMetadata.HeadOrNone()).Flatten();
-                            foreach (ArtistMetadata artistMetadata in maybeMetadata)
-                            {
-                                foreach (Genre genre in Optional(artistMetadata.Genres).Flatten())
-                                {
-                                    xml.WriteStartElement("category");
-                                    xml.WriteAttributeString("lang", "en");
-                                    xml.WriteString(genre.Name);
-                                    xml.WriteEndElement(); // category
-                                }
-                            }
-
-                            string thumbnail = Optional(metadata.Artwork).Flatten()
-                                .Filter(a => a.ArtworkKind == ArtworkKind.Thumbnail)
-                                .HeadOrNone()
-                                .Match(a => GetArtworkUrl(a, ArtworkKind.Thumbnail), () => string.Empty);
-
-                            if (!string.IsNullOrWhiteSpace(thumbnail))
-                            {
-                                xml.WriteStartElement("icon");
-                                xml.WriteAttributeString("src", thumbnail);
-                                xml.WriteEndElement(); // icon
-                            }
+                            xml.WriteStartElement("icon");
+                            xml.WriteAttributeString("src", poster);
+                            xml.WriteEndElement(); // icon
                         }
                     }
+                }
 
-                    if (!hasCustomTitle && displayItem.MediaItem is Song song)
+                if (!hasCustomTitle && displayItem.MediaItem is MusicVideo musicVideo)
+                {
+                    foreach (MusicVideoMetadata metadata in musicVideo.MusicVideoMetadata.HeadOrNone())
                     {
+                        if (metadata.Year.HasValue)
+                        {
+                            xml.WriteStartElement("date");
+                            xml.WriteString(metadata.Year.Value.ToString());
+                            xml.WriteEndElement(); // date
+                        }
+
                         xml.WriteStartElement("category");
                         xml.WriteAttributeString("lang", "en");
                         xml.WriteString("Music");
                         xml.WriteEndElement(); // category
 
-                        foreach (SongMetadata metadata in song.SongMetadata.HeadOrNone())
-                        {
-                            string thumbnail = Optional(metadata.Artwork).Flatten()
-                                .Filter(a => a.ArtworkKind == ArtworkKind.Thumbnail)
-                                .HeadOrNone()
-                                .Match(a => GetArtworkUrl(a, ArtworkKind.Thumbnail), () => string.Empty);
-
-                            if (!string.IsNullOrWhiteSpace(thumbnail))
-                            {
-                                xml.WriteStartElement("icon");
-                                xml.WriteAttributeString("src", thumbnail);
-                                xml.WriteEndElement(); // icon
-                            }
-                        }
-                    }
-
-                    if (displayItem.MediaItem is Episode episode && (!hasCustomTitle || isSameCustomShow))
-                    {
-                        Option<ShowMetadata> maybeMetadata =
-                            Optional(episode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten();
-                        foreach (ShowMetadata metadata in maybeMetadata)
+                        // music video genres
+                        foreach (Genre genre in Optional(metadata.Genres).Flatten())
                         {
                             xml.WriteStartElement("category");
                             xml.WriteAttributeString("lang", "en");
-                            xml.WriteString("Series");
+                            xml.WriteString(genre.Name);
                             xml.WriteEndElement(); // category
-                            
-                            foreach (Genre genre in Optional(metadata.Genres).Flatten())
+                        }
+
+                        // artist genres
+                        Option<ArtistMetadata> maybeMetadata =
+                            Optional(musicVideo.Artist?.ArtistMetadata.HeadOrNone()).Flatten();
+                        foreach (ArtistMetadata artistMetadata in maybeMetadata)
+                        {
+                            foreach (Genre genre in Optional(artistMetadata.Genres).Flatten())
                             {
                                 xml.WriteStartElement("category");
                                 xml.WriteAttributeString("lang", "en");
                                 xml.WriteString(genre.Name);
                                 xml.WriteEndElement(); // category
                             }
-
-                            string artwork = Optional(metadata.Artwork).Flatten()
-                                .Filter(a => a.ArtworkKind == ArtworkKind.Thumbnail)
-                                .HeadOrNone()
-                                .Match(a => GetArtworkUrl(a, ArtworkKind.Thumbnail), () => string.Empty);
-
-                            // fall back to poster
-                            if (string.IsNullOrWhiteSpace(artwork))
-                            {
-                                artwork = Optional(metadata.Artwork).Flatten()
-                                    .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
-                                    .HeadOrNone()
-                                    .Match(a => GetArtworkUrl(a, ArtworkKind.Poster), () => string.Empty);
-                            }
-
-                            if (!string.IsNullOrWhiteSpace(artwork))
-                            {
-                                xml.WriteStartElement("icon");
-                                xml.WriteAttributeString("src", artwork);
-                                xml.WriteEndElement(); // icon
-                            }
                         }
 
-                        if (!isSameCustomShow)
-                        {
-                            int s = Optional(episode.Season?.SeasonNumber).IfNone(-1);
-                            // TODO: multi-episode?
-                            int e = episode.EpisodeMetadata.HeadOrNone().Match(em => em.EpisodeNumber, -1);
-                            if (s >= 0 && e > 0)
-                            {
-                                xml.WriteStartElement("episode-num");
-                                xml.WriteAttributeString("system", "onscreen");
-                                xml.WriteString($"S{s:00}E{e:00}");
-                                xml.WriteEndElement(); // episode-num
+                        string thumbnail = Optional(metadata.Artwork).Flatten()
+                            .Filter(a => a.ArtworkKind == ArtworkKind.Thumbnail)
+                            .HeadOrNone()
+                            .Match(a => GetArtworkUrl(a, ArtworkKind.Thumbnail), () => string.Empty);
 
-                                xml.WriteStartElement("episode-num");
-                                xml.WriteAttributeString("system", "xmltv_ns");
-                                xml.WriteString($"{s - 1}.{e - 1}.0/1");
-                                xml.WriteEndElement(); // episode-num
-                            }
+                        if (!string.IsNullOrWhiteSpace(thumbnail))
+                        {
+                            xml.WriteStartElement("icon");
+                            xml.WriteAttributeString("src", thumbnail);
+                            xml.WriteEndElement(); // icon
                         }
                     }
-                    
-                    xml.WriteStartElement("previously-shown");
-                    xml.WriteEndElement(); // previously-shown
-
-                    foreach (ContentRating rating in contentRating)
-                    {
-                        xml.WriteStartElement("rating");
-                        foreach (string system in rating.System)
-                        {
-                            xml.WriteAttributeString("system", system);
-                        }
-
-                        xml.WriteStartElement("value");
-                        xml.WriteString(rating.Value);
-                        xml.WriteEndElement(); // value
-                        xml.WriteEndElement(); // rating
-                    }
-
-                    xml.WriteEndElement(); // programme
-
-                    i++;
                 }
-            }
 
-            xml.WriteEndElement(); // tv
-            xml.WriteEndDocument();
-
-            xml.Flush();
-            return Encoding.UTF8.GetString(ms.ToArray());
-        }
-
-        private string GetArtworkUrl(Artwork artwork, ArtworkKind artworkKind)
-        {
-            string artworkPath = artwork.Path;
-
-            int height = artworkKind switch
-            {
-                ArtworkKind.Thumbnail => 220,
-                _ => 440
-            };
-
-            if (artworkPath.StartsWith("jellyfin://"))
-            {
-                artworkPath = JellyfinUrl.ProxyForArtwork(_scheme, _host, artworkPath, artworkKind)
-                    .SetQueryParam("fillHeight", height);
-            }
-            else if (artworkPath.StartsWith("emby://"))
-            {
-                artworkPath = EmbyUrl.ProxyForArtwork(_scheme, _host, artworkPath, artworkKind)
-                    .SetQueryParam("maxHeight", height);
-            }
-            else
-            {
-                string artworkFolder = artworkKind switch
+                if (!hasCustomTitle && displayItem.MediaItem is Song song)
                 {
-                    ArtworkKind.Thumbnail => "thumbnails",
-                    _ => "posters"
-                };
+                    xml.WriteStartElement("category");
+                    xml.WriteAttributeString("lang", "en");
+                    xml.WriteString("Music");
+                    xml.WriteEndElement(); // category
 
-                artworkPath = $"{_scheme}://{_host}/iptv/artwork/{artworkFolder}/{artwork.Path}.jpg";
-            }
-
-            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]"),
-                Song s => s.SongMetadata.HeadOrNone().Map(sm => sm.Artist ?? string.Empty)
-                    .IfNone("[unknown artist]"),
-                _ => "[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 GetDescription(PlayoutItem playoutItem)
-        {
-            if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
-            {
-                return string.Empty;
-            }
-
-            return playoutItem.MediaItem switch
-            {
-                Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Plot ?? string.Empty).IfNone(string.Empty),
-                Episode e => e.EpisodeMetadata.HeadOrNone().Map(em => em.Plot ?? string.Empty)
-                    .IfNone(string.Empty),
-                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Map(mvm => mvm.Plot ?? string.Empty)
-                    .IfNone(string.Empty),
-                _ => string.Empty
-            };
-        }
-
-        private static Option<ContentRating> GetContentRating(PlayoutItem playoutItem)
-        {
-            try
-            {
-                return playoutItem.MediaItem switch
-                {
-                    Movie m => m.MovieMetadata
-                        .HeadOrNone()
-                        .Match(mm => ParseContentRating(mm.ContentRating, "MPAA"), () => None),
-                    Episode e => e.Season.Show.ShowMetadata
-                        .HeadOrNone()
-                        .Match(sm => ParseContentRating(sm.ContentRating, "VCHIP"), () => None),
-                    _ => None
-                };
-            }
-            catch (Exception ex)
-            {
-                Log.Logger.Warning(ex, "Failed to get content rating for playout item {Item}", GetTitle(playoutItem));
-                return None;
-            }
-        }
-
-        private static Option<ContentRating> ParseContentRating(string contentRating, string system)
-        {
-            Option<string> maybeFirst = (contentRating ?? string.Empty).Split('/').HeadOrNone();
-            return maybeFirst.Map(
-                first =>
-                {
-                    string[] split = first.Split(':');
-                    if (split.Length == 2)
+                    foreach (SongMetadata metadata in song.SongMetadata.HeadOrNone())
                     {
-                        return split[0].ToLowerInvariant() == "us"
-                            ? new ContentRating(system, split[1].ToUpperInvariant())
-                            : new ContentRating(None, split[1].ToUpperInvariant());
+                        string thumbnail = Optional(metadata.Artwork).Flatten()
+                            .Filter(a => a.ArtworkKind == ArtworkKind.Thumbnail)
+                            .HeadOrNone()
+                            .Match(a => GetArtworkUrl(a, ArtworkKind.Thumbnail), () => string.Empty);
+
+                        if (!string.IsNullOrWhiteSpace(thumbnail))
+                        {
+                            xml.WriteStartElement("icon");
+                            xml.WriteAttributeString("src", thumbnail);
+                            xml.WriteEndElement(); // icon
+                        }
+                    }
+                }
+
+                if (displayItem.MediaItem is Episode episode && (!hasCustomTitle || isSameCustomShow))
+                {
+                    Option<ShowMetadata> maybeMetadata =
+                        Optional(episode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten();
+                    foreach (ShowMetadata metadata in maybeMetadata)
+                    {
+                        xml.WriteStartElement("category");
+                        xml.WriteAttributeString("lang", "en");
+                        xml.WriteString("Series");
+                        xml.WriteEndElement(); // category
+                            
+                        foreach (Genre genre in Optional(metadata.Genres).Flatten())
+                        {
+                            xml.WriteStartElement("category");
+                            xml.WriteAttributeString("lang", "en");
+                            xml.WriteString(genre.Name);
+                            xml.WriteEndElement(); // category
+                        }
+
+                        string artwork = Optional(metadata.Artwork).Flatten()
+                            .Filter(a => a.ArtworkKind == ArtworkKind.Thumbnail)
+                            .HeadOrNone()
+                            .Match(a => GetArtworkUrl(a, ArtworkKind.Thumbnail), () => string.Empty);
+
+                        // fall back to poster
+                        if (string.IsNullOrWhiteSpace(artwork))
+                        {
+                            artwork = Optional(metadata.Artwork).Flatten()
+                                .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
+                                .HeadOrNone()
+                                .Match(a => GetArtworkUrl(a, ArtworkKind.Poster), () => string.Empty);
+                        }
+
+                        if (!string.IsNullOrWhiteSpace(artwork))
+                        {
+                            xml.WriteStartElement("icon");
+                            xml.WriteAttributeString("src", artwork);
+                            xml.WriteEndElement(); // icon
+                        }
                     }
 
-                    return string.IsNullOrWhiteSpace(first)
-                        ? Option<ContentRating>.None
-                        : new ContentRating(None, first);
-                }).Flatten();
+                    if (!isSameCustomShow)
+                    {
+                        int s = Optional(episode.Season?.SeasonNumber).IfNone(-1);
+                        // TODO: multi-episode?
+                        int e = episode.EpisodeMetadata.HeadOrNone().Match(em => em.EpisodeNumber, -1);
+                        if (s >= 0 && e > 0)
+                        {
+                            xml.WriteStartElement("episode-num");
+                            xml.WriteAttributeString("system", "onscreen");
+                            xml.WriteString($"S{s:00}E{e:00}");
+                            xml.WriteEndElement(); // episode-num
+
+                            xml.WriteStartElement("episode-num");
+                            xml.WriteAttributeString("system", "xmltv_ns");
+                            xml.WriteString($"{s - 1}.{e - 1}.0/1");
+                            xml.WriteEndElement(); // episode-num
+                        }
+                    }
+                }
+                    
+                xml.WriteStartElement("previously-shown");
+                xml.WriteEndElement(); // previously-shown
+
+                foreach (ContentRating rating in contentRating)
+                {
+                    xml.WriteStartElement("rating");
+                    foreach (string system in rating.System)
+                    {
+                        xml.WriteAttributeString("system", system);
+                    }
+
+                    xml.WriteStartElement("value");
+                    xml.WriteString(rating.Value);
+                    xml.WriteEndElement(); // value
+                    xml.WriteEndElement(); // rating
+                }
+
+                xml.WriteEndElement(); // programme
+
+                i++;
+            }
         }
 
-        private static List<string> GetCategories(string categories) =>
-            (categories ?? string.Empty).Split(',')
-            .Map(s => s.Trim())
-            .Filter(s => !string.IsNullOrWhiteSpace(s))
-            .Distinct()
-            .ToList();
+        xml.WriteEndElement(); // tv
+        xml.WriteEndDocument();
 
-        private record ContentRating(Option<string> System, string Value);
+        xml.Flush();
+        return Encoding.UTF8.GetString(ms.ToArray());
     }
-}
+
+    private string GetArtworkUrl(Artwork artwork, ArtworkKind artworkKind)
+    {
+        string artworkPath = artwork.Path;
+
+        int height = artworkKind switch
+        {
+            ArtworkKind.Thumbnail => 220,
+            _ => 440
+        };
+
+        if (artworkPath.StartsWith("jellyfin://"))
+        {
+            artworkPath = JellyfinUrl.ProxyForArtwork(_scheme, _host, artworkPath, artworkKind)
+                .SetQueryParam("fillHeight", height);
+        }
+        else if (artworkPath.StartsWith("emby://"))
+        {
+            artworkPath = EmbyUrl.ProxyForArtwork(_scheme, _host, artworkPath, artworkKind)
+                .SetQueryParam("maxHeight", height);
+        }
+        else
+        {
+            string artworkFolder = artworkKind switch
+            {
+                ArtworkKind.Thumbnail => "thumbnails",
+                _ => "posters"
+            };
+
+            artworkPath = $"{_scheme}://{_host}/iptv/artwork/{artworkFolder}/{artwork.Path}.jpg";
+        }
+
+        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]"),
+            Song s => s.SongMetadata.HeadOrNone().Map(sm => sm.Artist ?? string.Empty)
+                .IfNone("[unknown artist]"),
+            _ => "[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 GetDescription(PlayoutItem playoutItem)
+    {
+        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+        {
+            return string.Empty;
+        }
+
+        return playoutItem.MediaItem switch
+        {
+            Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Plot ?? string.Empty).IfNone(string.Empty),
+            Episode e => e.EpisodeMetadata.HeadOrNone().Map(em => em.Plot ?? string.Empty)
+                .IfNone(string.Empty),
+            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Map(mvm => mvm.Plot ?? string.Empty)
+                .IfNone(string.Empty),
+            _ => string.Empty
+        };
+    }
+
+    private static Option<ContentRating> GetContentRating(PlayoutItem playoutItem)
+    {
+        try
+        {
+            return playoutItem.MediaItem switch
+            {
+                Movie m => m.MovieMetadata
+                    .HeadOrNone()
+                    .Match(mm => ParseContentRating(mm.ContentRating, "MPAA"), () => None),
+                Episode e => e.Season.Show.ShowMetadata
+                    .HeadOrNone()
+                    .Match(sm => ParseContentRating(sm.ContentRating, "VCHIP"), () => None),
+                _ => None
+            };
+        }
+        catch (Exception ex)
+        {
+            Log.Logger.Warning(ex, "Failed to get content rating for playout item {Item}", GetTitle(playoutItem));
+            return None;
+        }
+    }
+
+    private static Option<ContentRating> ParseContentRating(string contentRating, string system)
+    {
+        Option<string> maybeFirst = (contentRating ?? string.Empty).Split('/').HeadOrNone();
+        return maybeFirst.Map(
+            first =>
+            {
+                string[] split = first.Split(':');
+                if (split.Length == 2)
+                {
+                    return split[0].ToLowerInvariant() == "us"
+                        ? new ContentRating(system, split[1].ToUpperInvariant())
+                        : new ContentRating(None, split[1].ToUpperInvariant());
+                }
+
+                return string.IsNullOrWhiteSpace(first)
+                    ? Option<ContentRating>.None
+                    : new ContentRating(None, first);
+            }).Flatten();
+    }
+
+    private static List<string> GetCategories(string categories) =>
+        (categories ?? string.Empty).Split(',')
+        .Map(s => s.Trim())
+        .Filter(s => !string.IsNullOrWhiteSpace(s))
+        .Distinct()
+        .ToList();
+
+    private record ContentRating(Option<string> System, string Value);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Iptv/ChannelPlaylist.cs b/ErsatzTV.Core/Iptv/ChannelPlaylist.cs
index 6f14f6bfb..6bb6b4371 100644
--- a/ErsatzTV.Core/Iptv/ChannelPlaylist.cs
+++ b/ErsatzTV.Core/Iptv/ChannelPlaylist.cs
@@ -1,62 +1,57 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Text;
 using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Iptv
+namespace ErsatzTV.Core.Iptv;
+
+public class ChannelPlaylist
 {
-    public class ChannelPlaylist
+    private readonly List<Channel> _channels;
+    private readonly string _host;
+    private readonly string _scheme;
+
+    public ChannelPlaylist(string scheme, string host, List<Channel> channels)
     {
-        private readonly List<Channel> _channels;
-        private readonly string _host;
-        private readonly string _scheme;
-
-        public ChannelPlaylist(string scheme, string host, List<Channel> channels)
-        {
-            _scheme = scheme;
-            _host = host;
-            _channels = channels;
-        }
-
-        public string ToM3U()
-        {
-            var sb = new StringBuilder();
-
-            var xmltv = $"{_scheme}://{_host}/iptv/xmltv.xml";
-            sb.AppendLine($"#EXTM3U url-tvg=\"{xmltv}\" x-tvg-url=\"{xmltv}\"");
-            foreach (Channel channel in _channels.OrderBy(c => decimal.Parse(c.Number)))
-            {
-                string logo = Optional(channel.Artwork).Flatten()
-                    .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
-                    .HeadOrNone()
-                    .Match(
-                        artwork => $"{_scheme}://{_host}/iptv/logos/{artwork.Path}.jpg",
-                        () => $"{_scheme}://{_host}/iptv/images/ersatztv-500.png");
-
-                string shortUniqueId = Convert.ToBase64String(channel.UniqueId.ToByteArray())
-                    .TrimEnd('=')
-                    .Replace("/", "_")
-                    .Replace("+", "-");
-
-                string format = channel.StreamingMode switch
-                {
-                    StreamingMode.HttpLiveStreamingDirect => "m3u8?mode=hls-direct",
-                    StreamingMode.HttpLiveStreamingSegmenter => "m3u8?mode=segmenter",
-                    StreamingMode.TransportStreamHybrid => "ts",
-                    _ => "ts?mode=ts-legacy"
-                };
-
-                string vcodec = channel.FFmpegProfile.VideoCodec.Split("_").Head();
-                string acodec = channel.FFmpegProfile.AudioCodec;
-
-                sb.AppendLine(
-                    $"#EXTINF:0 tvg-id=\"{channel.Number}.etv\" channel-id=\"{shortUniqueId}\" channel-number=\"{channel.Number}\" CUID=\"{shortUniqueId}\" tvg-chno=\"{channel.Number}\" tvg-name=\"{channel.Name}\" tvg-logo=\"{logo}\" group-title=\"{channel.Group}\" tvc-stream-vcodec=\"{vcodec}\" tvc-stream-acodec=\"{acodec}\", {channel.Name}");
-                sb.AppendLine($"{_scheme}://{_host}/iptv/channel/{channel.Number}.{format}");
-            }
-
-            return sb.ToString();
-        }
+        _scheme = scheme;
+        _host = host;
+        _channels = channels;
     }
-}
+
+    public string ToM3U()
+    {
+        var sb = new StringBuilder();
+
+        var xmltv = $"{_scheme}://{_host}/iptv/xmltv.xml";
+        sb.AppendLine($"#EXTM3U url-tvg=\"{xmltv}\" x-tvg-url=\"{xmltv}\"");
+        foreach (Channel channel in _channels.OrderBy(c => decimal.Parse(c.Number)))
+        {
+            string logo = Optional(channel.Artwork).Flatten()
+                .Filter(a => a.ArtworkKind == ArtworkKind.Logo)
+                .HeadOrNone()
+                .Match(
+                    artwork => $"{_scheme}://{_host}/iptv/logos/{artwork.Path}.jpg",
+                    () => $"{_scheme}://{_host}/iptv/images/ersatztv-500.png");
+
+            string shortUniqueId = Convert.ToBase64String(channel.UniqueId.ToByteArray())
+                .TrimEnd('=')
+                .Replace("/", "_")
+                .Replace("+", "-");
+
+            string format = channel.StreamingMode switch
+            {
+                StreamingMode.HttpLiveStreamingDirect => "m3u8?mode=hls-direct",
+                StreamingMode.HttpLiveStreamingSegmenter => "m3u8?mode=segmenter",
+                StreamingMode.TransportStreamHybrid => "ts",
+                _ => "ts?mode=ts-legacy"
+            };
+
+            string vcodec = channel.FFmpegProfile.VideoCodec.Split("_").Head();
+            string acodec = channel.FFmpegProfile.AudioCodec;
+
+            sb.AppendLine(
+                $"#EXTINF:0 tvg-id=\"{channel.Number}.etv\" channel-id=\"{shortUniqueId}\" channel-number=\"{channel.Number}\" CUID=\"{shortUniqueId}\" tvg-chno=\"{channel.Number}\" tvg-name=\"{channel.Name}\" tvg-logo=\"{logo}\" group-title=\"{channel.Group}\" tvc-stream-vcodec=\"{vcodec}\" tvc-stream-acodec=\"{acodec}\", {channel.Name}");
+            sb.AppendLine($"{_scheme}://{_host}/iptv/channel/{channel.Number}.{format}");
+        }
+
+        return sb.ToString();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Jellyfin/JellyfinItemEtag.cs b/ErsatzTV.Core/Jellyfin/JellyfinItemEtag.cs
index 4c8bee54e..19605bfa0 100644
--- a/ErsatzTV.Core/Jellyfin/JellyfinItemEtag.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinItemEtag.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.Jellyfin
+namespace ErsatzTV.Core.Jellyfin;
+
+public class JellyfinItemEtag
 {
-    public class JellyfinItemEtag
-    {
-        public string ItemId { get; set; }
-        public string Etag { get; set; }
-    }
-}
+    public string ItemId { get; set; }
+    public string Etag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Jellyfin/JellyfinMovieLibraryScanner.cs b/ErsatzTV.Core/Jellyfin/JellyfinMovieLibraryScanner.cs
index a90e2379a..5abe0eef2 100644
--- a/ErsatzTV.Core/Jellyfin/JellyfinMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinMovieLibraryScanner.cs
@@ -1,234 +1,227 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Jellyfin
+namespace ErsatzTV.Core.Jellyfin;
+
+public class JellyfinMovieLibraryScanner : IJellyfinMovieLibraryScanner
 {
-    public class JellyfinMovieLibraryScanner : IJellyfinMovieLibraryScanner
+    private readonly IJellyfinApiClient _jellyfinApiClient;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalStatisticsProvider _localStatisticsProvider;
+    private readonly ILogger<JellyfinMovieLibraryScanner> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediator _mediator;
+    private readonly IMovieRepository _movieRepository;
+    private readonly IJellyfinPathReplacementService _pathReplacementService;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+
+    public JellyfinMovieLibraryScanner(
+        IJellyfinApiClient jellyfinApiClient,
+        ISearchIndex searchIndex,
+        IMediator mediator,
+        IMovieRepository movieRepository,
+        ISearchRepository searchRepository,
+        IJellyfinPathReplacementService pathReplacementService,
+        IMediaSourceRepository mediaSourceRepository,
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILogger<JellyfinMovieLibraryScanner> logger)
     {
-        private readonly IJellyfinApiClient _jellyfinApiClient;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly ILogger<JellyfinMovieLibraryScanner> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMediator _mediator;
-        private readonly IMovieRepository _movieRepository;
-        private readonly IJellyfinPathReplacementService _pathReplacementService;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
+        _jellyfinApiClient = jellyfinApiClient;
+        _searchIndex = searchIndex;
+        _mediator = mediator;
+        _movieRepository = movieRepository;
+        _searchRepository = searchRepository;
+        _pathReplacementService = pathReplacementService;
+        _mediaSourceRepository = mediaSourceRepository;
+        _localFileSystem = localFileSystem;
+        _localStatisticsProvider = localStatisticsProvider;
+        _logger = logger;
+    }
 
-        public JellyfinMovieLibraryScanner(
-            IJellyfinApiClient jellyfinApiClient,
-            ISearchIndex searchIndex,
-            IMediator mediator,
-            IMovieRepository movieRepository,
-            ISearchRepository searchRepository,
-            IJellyfinPathReplacementService pathReplacementService,
-            IMediaSourceRepository mediaSourceRepository,
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILogger<JellyfinMovieLibraryScanner> logger)
-        {
-            _jellyfinApiClient = jellyfinApiClient;
-            _searchIndex = searchIndex;
-            _mediator = mediator;
-            _movieRepository = movieRepository;
-            _searchRepository = searchRepository;
-            _pathReplacementService = pathReplacementService;
-            _mediaSourceRepository = mediaSourceRepository;
-            _localFileSystem = localFileSystem;
-            _localStatisticsProvider = localStatisticsProvider;
-            _logger = logger;
-        }
+    public async Task<Either<BaseError, Unit>> ScanLibrary(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string ffprobePath)
+    {
+        List<JellyfinItemEtag> existingMovies = await _movieRepository.GetExistingJellyfinMovies(library);
 
-        public async Task<Either<BaseError, Unit>> ScanLibrary(
-            string address,
-            string apiKey,
-            JellyfinLibrary library,
-            string ffprobePath)
-        {
-            List<JellyfinItemEtag> existingMovies = await _movieRepository.GetExistingJellyfinMovies(library);
+        // TODO: maybe get quick list of item ids and etags from api to compare first
+        // TODO: paging?
 
-            // TODO: maybe get quick list of item ids and etags from api to compare first
-            // TODO: paging?
+        List<JellyfinPathReplacement> pathReplacements = await _mediaSourceRepository
+            .GetJellyfinPathReplacements(library.MediaSourceId);
 
-            List<JellyfinPathReplacement> pathReplacements = await _mediaSourceRepository
-                .GetJellyfinPathReplacements(library.MediaSourceId);
+        Either<BaseError, List<JellyfinMovie>> maybeMovies = await _jellyfinApiClient.GetMovieLibraryItems(
+            address,
+            apiKey,
+            library.MediaSourceId,
+            library.ItemId);
 
-            Either<BaseError, List<JellyfinMovie>> maybeMovies = await _jellyfinApiClient.GetMovieLibraryItems(
-                address,
-                apiKey,
-                library.MediaSourceId,
-                library.ItemId);
-
-            await maybeMovies.Match(
-                async movies =>
+        await maybeMovies.Match(
+            async movies =>
+            {
+                var validMovies = new List<JellyfinMovie>();
+                foreach (JellyfinMovie movie in movies.OrderBy(m => m.MovieMetadata.Head().Title))
                 {
-                    var validMovies = new List<JellyfinMovie>();
-                    foreach (JellyfinMovie movie in movies.OrderBy(m => m.MovieMetadata.Head().Title))
+                    string localPath = _pathReplacementService.GetReplacementJellyfinPath(
+                        pathReplacements,
+                        movie.MediaVersions.Head().MediaFiles.Head().Path,
+                        false);
+
+                    if (!_localFileSystem.FileExists(localPath))
+                    {
+                        _logger.LogWarning("Skipping jellyfin movie that does not exist at {Path}", localPath);
+                    }
+                    else
+                    {
+                        validMovies.Add(movie);
+                    }
+                }
+
+                foreach (JellyfinMovie incoming in validMovies)
+                {
+                    JellyfinMovie incomingMovie = incoming;
+
+                    decimal percentCompletion = (decimal) validMovies.IndexOf(incoming) / validMovies.Count;
+                    await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
+
+                    Option<JellyfinItemEtag> maybeExisting =
+                        existingMovies.Find(ie => ie.ItemId == incoming.ItemId);
+
+                    var updateStatistics = false;
+
+                    await maybeExisting.Match(
+                        async existing =>
+                        {
+                            try
+                            {
+                                if (existing.Etag == incoming.Etag)
+                                {
+                                    // _logger.LogDebug(
+                                    //     $"NOOP: Etag has not changed for movie {incoming.MovieMetadata.Head().Title}");
+                                    return;
+                                }
+
+                                _logger.LogDebug(
+                                    "UPDATE: Etag has changed for movie {Movie}",
+                                    incoming.MovieMetadata.Head().Title);
+
+                                updateStatistics = true;
+                                incoming.LibraryPathId = library.Paths.Head().Id;
+                                Option<JellyfinMovie> maybeUpdated = await _movieRepository.UpdateJellyfin(incoming);
+                                foreach (JellyfinMovie updated in maybeUpdated)
+                                {
+                                    await _searchIndex.UpdateItems(
+                                        _searchRepository,
+                                        new List<MediaItem> { updated });
+
+                                    incomingMovie = updated;
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                updateStatistics = false;
+                                _logger.LogError(
+                                    ex,
+                                    "Error updating movie {Movie}",
+                                    incoming.MovieMetadata.Head().Title);
+                            }
+                        },
+                        async () =>
+                        {
+                            try
+                            {
+                                // _logger.LogDebug(
+                                //     $"INSERT: Item id is new for movie {incoming.MovieMetadata.Head().Title}");
+
+                                updateStatistics = true;
+                                incoming.LibraryPathId = library.Paths.Head().Id;
+                                if (await _movieRepository.AddJellyfin(incoming))
+                                {
+                                    await _searchIndex.AddItems(
+                                        _searchRepository,
+                                        new List<MediaItem> { incoming });
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                updateStatistics = false;
+                                _logger.LogError(
+                                    ex,
+                                    "Error adding movie {Movie}",
+                                    incoming.MovieMetadata.Head().Title);
+                            }
+                        });
+
+                    if (updateStatistics)
                     {
                         string localPath = _pathReplacementService.GetReplacementJellyfinPath(
                             pathReplacements,
-                            movie.MediaVersions.Head().MediaFiles.Head().Path,
+                            incoming.MediaVersions.Head().MediaFiles.Head().Path,
                             false);
 
-                        if (!_localFileSystem.FileExists(localPath))
-                        {
-                            _logger.LogWarning("Skipping jellyfin movie that does not exist at {Path}", localPath);
-                        }
-                        else
-                        {
-                            validMovies.Add(movie);
-                        }
-                    }
+                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
+                        Either<BaseError, bool> refreshResult =
+                            await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingMovie, localPath);
 
-                    foreach (JellyfinMovie incoming in validMovies)
-                    {
-                        JellyfinMovie incomingMovie = incoming;
-
-                        decimal percentCompletion = (decimal) validMovies.IndexOf(incoming) / validMovies.Count;
-                        await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
-
-                        Option<JellyfinItemEtag> maybeExisting =
-                            existingMovies.Find(ie => ie.ItemId == incoming.ItemId);
-
-                        var updateStatistics = false;
-
-                        await maybeExisting.Match(
-                            async existing =>
+                        await refreshResult.Match(
+                            async _ =>
                             {
-                                try
+                                Option<MediaItem> updated = await _searchRepository.GetItemToIndex(incomingMovie.Id);
+                                if (updated.IsSome)
                                 {
-                                    if (existing.Etag == incoming.Etag)
-                                    {
-                                        // _logger.LogDebug(
-                                        //     $"NOOP: Etag has not changed for movie {incoming.MovieMetadata.Head().Title}");
-                                        return;
-                                    }
-
-                                    _logger.LogDebug(
-                                        "UPDATE: Etag has changed for movie {Movie}",
-                                        incoming.MovieMetadata.Head().Title);
-
-                                    updateStatistics = true;
-                                    incoming.LibraryPathId = library.Paths.Head().Id;
-                                    Option<JellyfinMovie> maybeUpdated = await _movieRepository.UpdateJellyfin(incoming);
-                                    foreach (JellyfinMovie updated in maybeUpdated)
-                                    {
-                                        await _searchIndex.UpdateItems(
-                                            _searchRepository,
-                                            new List<MediaItem> { updated });
-
-                                        incomingMovie = updated;
-                                    }
-                                }
-                                catch (Exception ex)
-                                {
-                                    updateStatistics = false;
-                                    _logger.LogError(
-                                        ex,
-                                        "Error updating movie {Movie}",
-                                        incoming.MovieMetadata.Head().Title);
+                                    await _searchIndex.UpdateItems(
+                                        _searchRepository,
+                                        new List<MediaItem> { updated.ValueUnsafe() });
                                 }
                             },
-                            async () =>
+                            error =>
                             {
-                                try
-                                {
-                                    // _logger.LogDebug(
-                                    //     $"INSERT: Item id is new for movie {incoming.MovieMetadata.Head().Title}");
+                                _logger.LogWarning(
+                                    "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                                    "Statistics",
+                                    localPath,
+                                    error.Value);
 
-                                    updateStatistics = true;
-                                    incoming.LibraryPathId = library.Paths.Head().Id;
-                                    if (await _movieRepository.AddJellyfin(incoming))
-                                    {
-                                        await _searchIndex.AddItems(
-                                            _searchRepository,
-                                            new List<MediaItem> { incoming });
-                                    }
-                                }
-                                catch (Exception ex)
-                                {
-                                    updateStatistics = false;
-                                    _logger.LogError(
-                                        ex,
-                                        "Error adding movie {Movie}",
-                                        incoming.MovieMetadata.Head().Title);
-                                }
+                                return Task.CompletedTask;
                             });
-
-                        if (updateStatistics)
-                        {
-                            string localPath = _pathReplacementService.GetReplacementJellyfinPath(
-                                pathReplacements,
-                                incoming.MediaVersions.Head().MediaFiles.Head().Path,
-                                false);
-
-                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
-                            Either<BaseError, bool> refreshResult =
-                                await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingMovie, localPath);
-
-                            await refreshResult.Match(
-                                async _ =>
-                                {
-                                    Option<MediaItem> updated = await _searchRepository.GetItemToIndex(incomingMovie.Id);
-                                    if (updated.IsSome)
-                                    {
-                                        await _searchIndex.UpdateItems(
-                                            _searchRepository,
-                                            new List<MediaItem> { updated.ValueUnsafe() });
-                                    }
-                                },
-                                error =>
-                                {
-                                    _logger.LogWarning(
-                                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                                        "Statistics",
-                                        localPath,
-                                        error.Value);
-
-                                    return Task.CompletedTask;
-                                });
-                        }
-
-                        // TODO: figure out how to rebuild playlists
                     }
 
-                    var incomingMovieIds = validMovies.Map(s => s.ItemId).ToList();
-                    var movieIds = existingMovies
-                        .Filter(i => !incomingMovieIds.Contains(i.ItemId))
-                        .Map(m => m.ItemId)
-                        .ToList();
-                    List<int> ids = await _movieRepository.RemoveMissingJellyfinMovies(library, movieIds);
-                    await _searchIndex.RemoveItems(ids);
+                    // TODO: figure out how to rebuild playlists
+                }
 
-                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
-                    _searchIndex.Commit();
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Error synchronizing jellyfin library {Path}: {Error}",
-                        library.Name,
-                        error.Value);
+                var incomingMovieIds = validMovies.Map(s => s.ItemId).ToList();
+                var movieIds = existingMovies
+                    .Filter(i => !incomingMovieIds.Contains(i.ItemId))
+                    .Map(m => m.ItemId)
+                    .ToList();
+                List<int> ids = await _movieRepository.RemoveMissingJellyfinMovies(library, movieIds);
+                await _searchIndex.RemoveItems(ids);
 
-                    return Task.CompletedTask;
-                });
+                await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+                _searchIndex.Commit();
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing jellyfin library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
 
-            _searchIndex.Commit();
-            return Unit.Default;
-        }
+                return Task.CompletedTask;
+            });
+
+        _searchIndex.Commit();
+        return Unit.Default;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Jellyfin/JellyfinPathReplacementService.cs b/ErsatzTV.Core/Jellyfin/JellyfinPathReplacementService.cs
index 503ff9383..b1cca0dbb 100644
--- a/ErsatzTV.Core/Jellyfin/JellyfinPathReplacementService.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinPathReplacementService.cs
@@ -1,90 +1,84 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Runtime;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Core.Jellyfin
+namespace ErsatzTV.Core.Jellyfin;
+
+public class JellyfinPathReplacementService : IJellyfinPathReplacementService
 {
-    public class JellyfinPathReplacementService : IJellyfinPathReplacementService
+    private readonly ILogger<JellyfinPathReplacementService> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IRuntimeInfo _runtimeInfo;
+
+    public JellyfinPathReplacementService(
+        IMediaSourceRepository mediaSourceRepository,
+        IRuntimeInfo runtimeInfo,
+        ILogger<JellyfinPathReplacementService> logger)
     {
-        private readonly ILogger<JellyfinPathReplacementService> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IRuntimeInfo _runtimeInfo;
-
-        public JellyfinPathReplacementService(
-            IMediaSourceRepository mediaSourceRepository,
-            IRuntimeInfo runtimeInfo,
-            ILogger<JellyfinPathReplacementService> logger)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _runtimeInfo = runtimeInfo;
-            _logger = logger;
-        }
-
-        public async Task<string> GetReplacementJellyfinPath(int libraryPathId, string path)
-        {
-            List<JellyfinPathReplacement> replacements =
-                await _mediaSourceRepository.GetJellyfinPathReplacementsByLibraryId(libraryPathId);
-
-            return GetReplacementJellyfinPath(replacements, path);
-        }
-
-        public string GetReplacementJellyfinPath(
-            List<JellyfinPathReplacement> pathReplacements,
-            string path,
-            bool log = true)
-        {
-            Option<JellyfinPathReplacement> maybeReplacement = pathReplacements
-                .SingleOrDefault(
-                    r =>
-                    {
-                        string separatorChar = IsWindows(r.JellyfinMediaSource, path) ? @"\" : @"/";
-                        string prefix = r.JellyfinPath.EndsWith(separatorChar)
-                            ? r.JellyfinPath
-                            : r.JellyfinPath + separatorChar;
-                        return path.StartsWith(prefix);
-                    });
-
-            return maybeReplacement.Match(
-                replacement =>
-                {
-                    string finalPath = path.Replace(replacement.JellyfinPath, replacement.LocalPath);
-                    if (IsWindows(replacement.JellyfinMediaSource, path) &&
-                        !_runtimeInfo.IsOSPlatform(OSPlatform.Windows))
-                    {
-                        finalPath = finalPath.Replace(@"\", @"/");
-                    }
-                    else if (!IsWindows(replacement.JellyfinMediaSource, path) &&
-                             _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
-                    {
-                        finalPath = finalPath.Replace(@"/", @"\");
-                    }
-
-                    if (log)
-                    {
-                        _logger.LogInformation(
-                            "Replacing jellyfin path {JellyfinPath} with {LocalPath} resulting in {FinalPath}",
-                            replacement.JellyfinPath,
-                            replacement.LocalPath,
-                            finalPath);
-                    }
-
-                    return finalPath;
-                },
-                () => path);
-        }
-
-        private static bool IsWindows(JellyfinMediaSource jellyfinMediaSource, string path)
-        {
-            bool isUnc = Uri.TryCreate(path, UriKind.Absolute, out Uri uri) && uri.IsUnc;
-            return isUnc || jellyfinMediaSource.OperatingSystem.ToLowerInvariant().StartsWith("windows");
-        }
+        _mediaSourceRepository = mediaSourceRepository;
+        _runtimeInfo = runtimeInfo;
+        _logger = logger;
     }
-}
+
+    public async Task<string> GetReplacementJellyfinPath(int libraryPathId, string path)
+    {
+        List<JellyfinPathReplacement> replacements =
+            await _mediaSourceRepository.GetJellyfinPathReplacementsByLibraryId(libraryPathId);
+
+        return GetReplacementJellyfinPath(replacements, path);
+    }
+
+    public string GetReplacementJellyfinPath(
+        List<JellyfinPathReplacement> pathReplacements,
+        string path,
+        bool log = true)
+    {
+        Option<JellyfinPathReplacement> maybeReplacement = pathReplacements
+            .SingleOrDefault(
+                r =>
+                {
+                    string separatorChar = IsWindows(r.JellyfinMediaSource, path) ? @"\" : @"/";
+                    string prefix = r.JellyfinPath.EndsWith(separatorChar)
+                        ? r.JellyfinPath
+                        : r.JellyfinPath + separatorChar;
+                    return path.StartsWith(prefix);
+                });
+
+        return maybeReplacement.Match(
+            replacement =>
+            {
+                string finalPath = path.Replace(replacement.JellyfinPath, replacement.LocalPath);
+                if (IsWindows(replacement.JellyfinMediaSource, path) &&
+                    !_runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                {
+                    finalPath = finalPath.Replace(@"\", @"/");
+                }
+                else if (!IsWindows(replacement.JellyfinMediaSource, path) &&
+                         _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                {
+                    finalPath = finalPath.Replace(@"/", @"\");
+                }
+
+                if (log)
+                {
+                    _logger.LogInformation(
+                        "Replacing jellyfin path {JellyfinPath} with {LocalPath} resulting in {FinalPath}",
+                        replacement.JellyfinPath,
+                        replacement.LocalPath,
+                        finalPath);
+                }
+
+                return finalPath;
+            },
+            () => path);
+    }
+
+    private static bool IsWindows(JellyfinMediaSource jellyfinMediaSource, string path)
+    {
+        bool isUnc = Uri.TryCreate(path, UriKind.Absolute, out Uri uri) && uri.IsUnc;
+        return isUnc || jellyfinMediaSource.OperatingSystem.ToLowerInvariant().StartsWith("windows");
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Jellyfin/JellyfinSecrets.cs b/ErsatzTV.Core/Jellyfin/JellyfinSecrets.cs
index a953103b1..3730fee26 100644
--- a/ErsatzTV.Core/Jellyfin/JellyfinSecrets.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinSecrets.cs
@@ -1,8 +1,7 @@
 using ErsatzTV.Core.MediaSources;
 
-namespace ErsatzTV.Core.Jellyfin
+namespace ErsatzTV.Core.Jellyfin;
+
+public class JellyfinSecrets : RemoteMediaSourceSecrets
 {
-    public class JellyfinSecrets : RemoteMediaSourceSecrets
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Jellyfin/JellyfinServerInformation.cs b/ErsatzTV.Core/Jellyfin/JellyfinServerInformation.cs
index 3d1fe75d6..8f2540f93 100644
--- a/ErsatzTV.Core/Jellyfin/JellyfinServerInformation.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinServerInformation.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Core.Jellyfin
-{
-    public record JellyfinServerInformation(string ServerName, string OperatingSystem);
-}
+namespace ErsatzTV.Core.Jellyfin;
+
+public record JellyfinServerInformation(string ServerName, string OperatingSystem);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Jellyfin/JellyfinTelevisionLibraryScanner.cs b/ErsatzTV.Core/Jellyfin/JellyfinTelevisionLibraryScanner.cs
index 6c9d7fd10..04fcbc173 100644
--- a/ErsatzTV.Core/Jellyfin/JellyfinTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinTelevisionLibraryScanner.cs
@@ -1,96 +1,306 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Jellyfin
+namespace ErsatzTV.Core.Jellyfin;
+
+public class JellyfinTelevisionLibraryScanner : IJellyfinTelevisionLibraryScanner
 {
-    public class JellyfinTelevisionLibraryScanner : IJellyfinTelevisionLibraryScanner
+    private readonly IJellyfinApiClient _jellyfinApiClient;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalStatisticsProvider _localStatisticsProvider;
+    private readonly ILogger<JellyfinTelevisionLibraryScanner> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediator _mediator;
+    private readonly IJellyfinPathReplacementService _pathReplacementService;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+    private readonly IJellyfinTelevisionRepository _televisionRepository;
+
+    public JellyfinTelevisionLibraryScanner(
+        IJellyfinApiClient jellyfinApiClient,
+        IMediaSourceRepository mediaSourceRepository,
+        IJellyfinTelevisionRepository televisionRepository,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        IJellyfinPathReplacementService pathReplacementService,
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        IMediator mediator,
+        ILogger<JellyfinTelevisionLibraryScanner> logger)
     {
-        private readonly IJellyfinApiClient _jellyfinApiClient;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly ILogger<JellyfinTelevisionLibraryScanner> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMediator _mediator;
-        private readonly IJellyfinPathReplacementService _pathReplacementService;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
-        private readonly IJellyfinTelevisionRepository _televisionRepository;
+        _jellyfinApiClient = jellyfinApiClient;
+        _mediaSourceRepository = mediaSourceRepository;
+        _televisionRepository = televisionRepository;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _pathReplacementService = pathReplacementService;
+        _localFileSystem = localFileSystem;
+        _localStatisticsProvider = localStatisticsProvider;
+        _mediator = mediator;
+        _logger = logger;
+    }
 
-        public JellyfinTelevisionLibraryScanner(
-            IJellyfinApiClient jellyfinApiClient,
-            IMediaSourceRepository mediaSourceRepository,
-            IJellyfinTelevisionRepository televisionRepository,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            IJellyfinPathReplacementService pathReplacementService,
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            IMediator mediator,
-            ILogger<JellyfinTelevisionLibraryScanner> logger)
+    public async Task<Either<BaseError, Unit>> ScanLibrary(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string ffprobePath)
+    {
+        List<JellyfinItemEtag> existingShows = await _televisionRepository.GetExistingShows(library);
+
+        // TODO: maybe get quick list of item ids and etags from api to compare first
+        // TODO: paging?
+
+        List<JellyfinPathReplacement> pathReplacements = await _mediaSourceRepository
+            .GetJellyfinPathReplacements(library.MediaSourceId);
+
+        Either<BaseError, List<JellyfinShow>> maybeShows = await _jellyfinApiClient.GetShowLibraryItems(
+            address,
+            apiKey,
+            library.MediaSourceId,
+            library.ItemId);
+
+        await maybeShows.Match(
+            async shows =>
+            {
+                await ProcessShows(address, apiKey, library, ffprobePath, pathReplacements, existingShows, shows);
+
+                var incomingShowIds = shows.Map(s => s.ItemId).ToList();
+                var showIds = existingShows
+                    .Filter(i => !incomingShowIds.Contains(i.ItemId))
+                    .Map(m => m.ItemId)
+                    .ToList();
+                List<int> missingShowIds = await _televisionRepository.RemoveMissingShows(library, showIds);
+                await _searchIndex.RemoveItems(missingShowIds);
+
+                await _televisionRepository.DeleteEmptySeasons(library);
+                List<int> emptyShowIds = await _televisionRepository.DeleteEmptyShows(library);
+                await _searchIndex.RemoveItems(emptyShowIds);
+
+                await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+                _searchIndex.Commit();
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing jellyfin library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
+
+                return Task.CompletedTask;
+            });
+
+        return Unit.Default;
+    }
+
+    private async Task ProcessShows(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string ffprobePath,
+        List<JellyfinPathReplacement> pathReplacements,
+        List<JellyfinItemEtag> existingShows,
+        List<JellyfinShow> shows)
+    {
+        var sortedShows = shows.OrderBy(s => s.ShowMetadata.Head().Title).ToList();
+        foreach (JellyfinShow incoming in sortedShows)
         {
-            _jellyfinApiClient = jellyfinApiClient;
-            _mediaSourceRepository = mediaSourceRepository;
-            _televisionRepository = televisionRepository;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _pathReplacementService = pathReplacementService;
-            _localFileSystem = localFileSystem;
-            _localStatisticsProvider = localStatisticsProvider;
-            _mediator = mediator;
-            _logger = logger;
-        }
+            decimal percentCompletion = (decimal) sortedShows.IndexOf(incoming) / shows.Count;
+            await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
 
-        public async Task<Either<BaseError, Unit>> ScanLibrary(
-            string address,
-            string apiKey,
-            JellyfinLibrary library,
-            string ffprobePath)
-        {
-            List<JellyfinItemEtag> existingShows = await _televisionRepository.GetExistingShows(library);
-
-            // TODO: maybe get quick list of item ids and etags from api to compare first
-            // TODO: paging?
-
-            List<JellyfinPathReplacement> pathReplacements = await _mediaSourceRepository
-                .GetJellyfinPathReplacements(library.MediaSourceId);
-
-            Either<BaseError, List<JellyfinShow>> maybeShows = await _jellyfinApiClient.GetShowLibraryItems(
-                address,
-                apiKey,
-                library.MediaSourceId,
-                library.ItemId);
-
-            await maybeShows.Match(
-                async shows =>
+            Option<JellyfinItemEtag> maybeExisting = existingShows.Find(ie => ie.ItemId == incoming.ItemId);
+            await maybeExisting.Match(
+                async existing =>
                 {
-                    await ProcessShows(address, apiKey, library, ffprobePath, pathReplacements, existingShows, shows);
+                    if (existing.Etag == incoming.Etag)
+                    {
+                        return;
+                    }
 
-                    var incomingShowIds = shows.Map(s => s.ItemId).ToList();
-                    var showIds = existingShows
-                        .Filter(i => !incomingShowIds.Contains(i.ItemId))
+                    _logger.LogDebug(
+                        "UPDATE: Etag has changed for show {Show}",
+                        incoming.ShowMetadata.Head().Title);
+
+                    incoming.LibraryPathId = library.Paths.Head().Id;
+
+                    Option<JellyfinShow> updated = await _televisionRepository.Update(incoming);
+                    if (updated.IsSome)
+                    {
+                        await _searchIndex.UpdateItems(
+                            _searchRepository,
+                            new List<MediaItem> { updated.ValueUnsafe() });
+                    }
+                },
+                async () =>
+                {
+                    incoming.LibraryPathId = library.Paths.Head().Id;
+
+                    // _logger.LogDebug("INSERT: Item id is new for show {Show}", incoming.ShowMetadata.Head().Title);
+
+                    if (await _televisionRepository.AddShow(incoming))
+                    {
+                        await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
+                    }
+                });
+
+            List<JellyfinItemEtag> existingSeasons =
+                await _televisionRepository.GetExistingSeasons(library, incoming.ItemId);
+
+            Either<BaseError, List<JellyfinSeason>> maybeSeasons =
+                await _jellyfinApiClient.GetSeasonLibraryItems(
+                    address,
+                    apiKey,
+                    library.MediaSourceId,
+                    incoming.ItemId);
+
+            await maybeSeasons.Match(
+                async seasons =>
+                {
+                    await ProcessSeasons(
+                        address,
+                        apiKey,
+                        library,
+                        ffprobePath,
+                        pathReplacements,
+                        incoming,
+                        existingSeasons,
+                        seasons);
+
+                    var incomingSeasonIds = seasons.Map(s => s.ItemId).ToList();
+                    var seasonIds = existingSeasons
+                        .Filter(i => !incomingSeasonIds.Contains(i.ItemId))
                         .Map(m => m.ItemId)
                         .ToList();
-                    List<int> missingShowIds = await _televisionRepository.RemoveMissingShows(library, showIds);
-                    await _searchIndex.RemoveItems(missingShowIds);
+                    await _televisionRepository.RemoveMissingSeasons(library, seasonIds);
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Error synchronizing jellyfin library {Path}: {Error}",
+                        library.Name,
+                        error.Value);
 
-                    await _televisionRepository.DeleteEmptySeasons(library);
-                    List<int> emptyShowIds = await _televisionRepository.DeleteEmptyShows(library);
-                    await _searchIndex.RemoveItems(emptyShowIds);
+                    return Task.CompletedTask;
+                });
+        }
+    }
 
-                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+    private async Task ProcessSeasons(
+        string address,
+        string apiKey,
+        JellyfinLibrary library,
+        string ffprobePath,
+        List<JellyfinPathReplacement> pathReplacements,
+        JellyfinShow show,
+        List<JellyfinItemEtag> existingSeasons,
+        List<JellyfinSeason> seasons)
+    {
+        foreach (JellyfinSeason incoming in seasons)
+        {
+            Option<JellyfinItemEtag> maybeExisting = existingSeasons.Find(ie => ie.ItemId == incoming.ItemId);
+            await maybeExisting.Match(
+                async existing =>
+                {
+                    if (existing.Etag == incoming.Etag)
+                    {
+                        return;
+                    }
+
+                    _logger.LogDebug(
+                        "UPDATE: Etag has changed for show {Show} season {Season}",
+                        show.ShowMetadata.Head().Title,
+                        incoming.SeasonMetadata.Head().Title);
+
+                    incoming.ShowId = show.Id;
+                    incoming.LibraryPathId = library.Paths.Head().Id;
+
+                    foreach (JellyfinSeason updated in await _televisionRepository.Update(incoming))
+                    {
+                        incoming.Show = show;
+
+                        foreach (MediaItem toIndex in await _searchRepository.GetItemToIndex(updated.Id))
+                        {
+                            await _searchIndex.UpdateItems(
+                                _searchRepository,
+                                new List<MediaItem> { toIndex });
+                        }
+                    }
+                },
+                async () =>
+                {
+                    incoming.LibraryPathId = library.Paths.Head().Id;
+
+                    _logger.LogDebug(
+                        "INSERT: Item id is new for show {Show} season {Season}",
+                        show.ShowMetadata.Head().Title,
+                        incoming.SeasonMetadata.Head().Title);
+
+                    if (await _televisionRepository.AddSeason(show, incoming))
+                    {
+                        incoming.Show = show;
+                        await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
+                    }
+                });
+
+            List<JellyfinItemEtag> existingEpisodes =
+                await _televisionRepository.GetExistingEpisodes(library, incoming.ItemId);
+
+            Either<BaseError, List<JellyfinEpisode>> maybeEpisodes =
+                await _jellyfinApiClient.GetEpisodeLibraryItems(
+                    address,
+                    apiKey,
+                    library.MediaSourceId,
+                    incoming.ItemId);
+
+            await maybeEpisodes.Match(
+                async episodes =>
+                {
+                    var validEpisodes = new List<JellyfinEpisode>();
+                    foreach (JellyfinEpisode episode in episodes)
+                    {
+                        string localPath = _pathReplacementService.GetReplacementJellyfinPath(
+                            pathReplacements,
+                            episode.MediaVersions.Head().MediaFiles.Head().Path,
+                            false);
+
+                        if (!_localFileSystem.FileExists(localPath))
+                        {
+                            _logger.LogWarning(
+                                "Skipping jellyfin episode that does not exist at {Path}",
+                                localPath);
+                        }
+                        else
+                        {
+                            validEpisodes.Add(episode);
+                        }
+                    }
+
+                    await ProcessEpisodes(
+                        show.ShowMetadata.Head().Title,
+                        incoming.SeasonMetadata.Head().Title,
+                        library,
+                        ffprobePath,
+                        pathReplacements,
+                        incoming,
+                        existingEpisodes,
+                        validEpisodes);
+
+                    var incomingEpisodeIds = episodes.Map(s => s.ItemId).ToList();
+                    var episodeIds = existingEpisodes
+                        .Filter(i => !incomingEpisodeIds.Contains(i.ItemId))
+                        .Map(m => m.ItemId)
+                        .ToList();
+
+                    List<int> missingEpisodeIds =
+                        await _televisionRepository.RemoveMissingEpisodes(library, episodeIds);
+                    await _searchIndex.RemoveItems(missingEpisodeIds);
                     _searchIndex.Commit();
                 },
                 error =>
@@ -102,28 +312,30 @@ namespace ErsatzTV.Core.Jellyfin
 
                     return Task.CompletedTask;
                 });
-
-            return Unit.Default;
         }
+    }
 
-        private async Task ProcessShows(
-            string address,
-            string apiKey,
-            JellyfinLibrary library,
-            string ffprobePath,
-            List<JellyfinPathReplacement> pathReplacements,
-            List<JellyfinItemEtag> existingShows,
-            List<JellyfinShow> shows)
+    private async Task ProcessEpisodes(
+        string showName,
+        string seasonName,
+        JellyfinLibrary library,
+        string ffprobePath,
+        List<JellyfinPathReplacement> pathReplacements,
+        JellyfinSeason season,
+        List<JellyfinItemEtag> existingEpisodes,
+        List<JellyfinEpisode> episodes)
+    {
+        foreach (JellyfinEpisode incoming in episodes)
         {
-            var sortedShows = shows.OrderBy(s => s.ShowMetadata.Head().Title).ToList();
-            foreach (JellyfinShow incoming in sortedShows)
-            {
-                decimal percentCompletion = (decimal) sortedShows.IndexOf(incoming) / shows.Count;
-                await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
+            JellyfinEpisode incomingEpisode = incoming;
+                
+            var updateStatistics = false;
 
-                Option<JellyfinItemEtag> maybeExisting = existingShows.Find(ie => ie.ItemId == incoming.ItemId);
-                await maybeExisting.Match(
-                    async existing =>
+            Option<JellyfinItemEtag> maybeExisting = existingEpisodes.Find(ie => ie.ItemId == incoming.ItemId);
+            await maybeExisting.Match(
+                async existing =>
+                {
+                    try
                     {
                         if (existing.Etag == incoming.Etag)
                         {
@@ -131,300 +343,81 @@ namespace ErsatzTV.Core.Jellyfin
                         }
 
                         _logger.LogDebug(
-                            "UPDATE: Etag has changed for show {Show}",
-                            incoming.ShowMetadata.Head().Title);
+                            "UPDATE: Etag has changed for show {Show} season {Season} episode {Episode}",
+                            showName,
+                            seasonName,
+                            incoming.EpisodeMetadata.HeadOrNone().Map(em => em.EpisodeNumber));
 
+                        updateStatistics = true;
+                        incoming.SeasonId = season.Id;
                         incoming.LibraryPathId = library.Paths.Head().Id;
 
-                        Option<JellyfinShow> updated = await _televisionRepository.Update(incoming);
-                        if (updated.IsSome)
+                        Option<JellyfinEpisode> maybeUpdated = await _televisionRepository.Update(incoming);
+                        foreach (JellyfinEpisode updated in maybeUpdated)
                         {
                             await _searchIndex.UpdateItems(
                                 _searchRepository,
-                                new List<MediaItem> { updated.ValueUnsafe() });
+                                new List<MediaItem> { updated });
+
+                            incomingEpisode = updated;
                         }
-                    },
-                    async () =>
+                    }
+                    catch (Exception ex)
                     {
-                        incoming.LibraryPathId = library.Paths.Head().Id;
-
-                        // _logger.LogDebug("INSERT: Item id is new for show {Show}", incoming.ShowMetadata.Head().Title);
-
-                        if (await _televisionRepository.AddShow(incoming))
-                        {
-                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
-                        }
-                    });
-
-                List<JellyfinItemEtag> existingSeasons =
-                    await _televisionRepository.GetExistingSeasons(library, incoming.ItemId);
-
-                Either<BaseError, List<JellyfinSeason>> maybeSeasons =
-                    await _jellyfinApiClient.GetSeasonLibraryItems(
-                        address,
-                        apiKey,
-                        library.MediaSourceId,
-                        incoming.ItemId);
-
-                await maybeSeasons.Match(
-                    async seasons =>
-                    {
-                        await ProcessSeasons(
-                            address,
-                            apiKey,
-                            library,
-                            ffprobePath,
-                            pathReplacements,
-                            incoming,
-                            existingSeasons,
-                            seasons);
-
-                        var incomingSeasonIds = seasons.Map(s => s.ItemId).ToList();
-                        var seasonIds = existingSeasons
-                            .Filter(i => !incomingSeasonIds.Contains(i.ItemId))
-                            .Map(m => m.ItemId)
-                            .ToList();
-                        await _televisionRepository.RemoveMissingSeasons(library, seasonIds);
-                    },
-                    error =>
-                    {
-                        _logger.LogWarning(
-                            "Error synchronizing jellyfin library {Path}: {Error}",
-                            library.Name,
-                            error.Value);
-
-                        return Task.CompletedTask;
-                    });
-            }
-        }
-
-        private async Task ProcessSeasons(
-            string address,
-            string apiKey,
-            JellyfinLibrary library,
-            string ffprobePath,
-            List<JellyfinPathReplacement> pathReplacements,
-            JellyfinShow show,
-            List<JellyfinItemEtag> existingSeasons,
-            List<JellyfinSeason> seasons)
-        {
-            foreach (JellyfinSeason incoming in seasons)
-            {
-                Option<JellyfinItemEtag> maybeExisting = existingSeasons.Find(ie => ie.ItemId == incoming.ItemId);
-                await maybeExisting.Match(
-                    async existing =>
-                    {
-                        if (existing.Etag == incoming.Etag)
-                        {
-                            return;
-                        }
-
-                        _logger.LogDebug(
-                            "UPDATE: Etag has changed for show {Show} season {Season}",
-                            show.ShowMetadata.Head().Title,
-                            incoming.SeasonMetadata.Head().Title);
-
-                        incoming.ShowId = show.Id;
-                        incoming.LibraryPathId = library.Paths.Head().Id;
-
-                        foreach (JellyfinSeason updated in await _televisionRepository.Update(incoming))
-                        {
-                            incoming.Show = show;
-
-                            foreach (MediaItem toIndex in await _searchRepository.GetItemToIndex(updated.Id))
-                            {
-                                await _searchIndex.UpdateItems(
-                                    _searchRepository,
-                                    new List<MediaItem> { toIndex });
-                            }
-                        }
-                    },
-                    async () =>
-                    {
-                        incoming.LibraryPathId = library.Paths.Head().Id;
-
-                        _logger.LogDebug(
-                            "INSERT: Item id is new for show {Show} season {Season}",
-                            show.ShowMetadata.Head().Title,
-                            incoming.SeasonMetadata.Head().Title);
-
-                        if (await _televisionRepository.AddSeason(show, incoming))
-                        {
-                            incoming.Show = show;
-                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
-                        }
-                    });
-
-                List<JellyfinItemEtag> existingEpisodes =
-                    await _televisionRepository.GetExistingEpisodes(library, incoming.ItemId);
-
-                Either<BaseError, List<JellyfinEpisode>> maybeEpisodes =
-                    await _jellyfinApiClient.GetEpisodeLibraryItems(
-                        address,
-                        apiKey,
-                        library.MediaSourceId,
-                        incoming.ItemId);
-
-                await maybeEpisodes.Match(
-                    async episodes =>
-                    {
-                        var validEpisodes = new List<JellyfinEpisode>();
-                        foreach (JellyfinEpisode episode in episodes)
-                        {
-                            string localPath = _pathReplacementService.GetReplacementJellyfinPath(
-                                pathReplacements,
-                                episode.MediaVersions.Head().MediaFiles.Head().Path,
-                                false);
-
-                            if (!_localFileSystem.FileExists(localPath))
-                            {
-                                _logger.LogWarning(
-                                    "Skipping jellyfin episode that does not exist at {Path}",
-                                    localPath);
-                            }
-                            else
-                            {
-                                validEpisodes.Add(episode);
-                            }
-                        }
-
-                        await ProcessEpisodes(
-                            show.ShowMetadata.Head().Title,
-                            incoming.SeasonMetadata.Head().Title,
-                            library,
-                            ffprobePath,
-                            pathReplacements,
-                            incoming,
-                            existingEpisodes,
-                            validEpisodes);
-
-                        var incomingEpisodeIds = episodes.Map(s => s.ItemId).ToList();
-                        var episodeIds = existingEpisodes
-                            .Filter(i => !incomingEpisodeIds.Contains(i.ItemId))
-                            .Map(m => m.ItemId)
-                            .ToList();
-
-                        List<int> missingEpisodeIds =
-                            await _televisionRepository.RemoveMissingEpisodes(library, episodeIds);
-                        await _searchIndex.RemoveItems(missingEpisodeIds);
-                        _searchIndex.Commit();
-                    },
-                    error =>
-                    {
-                        _logger.LogWarning(
-                            "Error synchronizing jellyfin library {Path}: {Error}",
-                            library.Name,
-                            error.Value);
-
-                        return Task.CompletedTask;
-                    });
-            }
-        }
-
-        private async Task ProcessEpisodes(
-            string showName,
-            string seasonName,
-            JellyfinLibrary library,
-            string ffprobePath,
-            List<JellyfinPathReplacement> pathReplacements,
-            JellyfinSeason season,
-            List<JellyfinItemEtag> existingEpisodes,
-            List<JellyfinEpisode> episodes)
-        {
-            foreach (JellyfinEpisode incoming in episodes)
-            {
-                JellyfinEpisode incomingEpisode = incoming;
-                
-                var updateStatistics = false;
-
-                Option<JellyfinItemEtag> maybeExisting = existingEpisodes.Find(ie => ie.ItemId == incoming.ItemId);
-                await maybeExisting.Match(
-                    async existing =>
-                    {
-                        try
-                        {
-                            if (existing.Etag == incoming.Etag)
-                            {
-                                return;
-                            }
-
-                            _logger.LogDebug(
-                                "UPDATE: Etag has changed for show {Show} season {Season} episode {Episode}",
-                                showName,
-                                seasonName,
-                                incoming.EpisodeMetadata.HeadOrNone().Map(em => em.EpisodeNumber));
-
-                            updateStatistics = true;
-                            incoming.SeasonId = season.Id;
-                            incoming.LibraryPathId = library.Paths.Head().Id;
-
-                            Option<JellyfinEpisode> maybeUpdated = await _televisionRepository.Update(incoming);
-                            foreach (JellyfinEpisode updated in maybeUpdated)
-                            {
-                                await _searchIndex.UpdateItems(
-                                    _searchRepository,
-                                    new List<MediaItem> { updated });
-
-                                incomingEpisode = updated;
-                            }
-                        }
-                        catch (Exception ex)
-                        {
-                            updateStatistics = false;
-                            _logger.LogError(
-                                ex,
-                                "Error updating episode {Path}",
-                                incoming.MediaVersions.Head().MediaFiles.Head().Path);
-                        }
-                    },
-                    async () =>
-                    {
-                        try
-                        {
-                            updateStatistics = true;
-                            incoming.LibraryPathId = library.Paths.Head().Id;
-
-                            _logger.LogDebug(
-                                "INSERT: Item id is new for show {Show} season {Season} episode {Episode}",
-                                showName,
-                                seasonName,
-                                incoming.EpisodeMetadata.HeadOrNone().Map(em => em.EpisodeNumber));
-
-                            if (await _televisionRepository.AddEpisode(season, incoming))
-                            {
-                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
-                            }
-                        }
-                        catch (Exception ex)
-                        {
-                            updateStatistics = false;
-                            _logger.LogError(
-                                ex,
-                                "Error adding episode {Path}",
-                                incoming.MediaVersions.Head().MediaFiles.Head().Path);
-                        }
-                    });
-
-                if (updateStatistics)
+                        updateStatistics = false;
+                        _logger.LogError(
+                            ex,
+                            "Error updating episode {Path}",
+                            incoming.MediaVersions.Head().MediaFiles.Head().Path);
+                    }
+                },
+                async () =>
                 {
-                    string localPath = _pathReplacementService.GetReplacementJellyfinPath(
-                        pathReplacements,
-                        incoming.MediaVersions.Head().MediaFiles.Head().Path,
-                        false);
+                    try
+                    {
+                        updateStatistics = true;
+                        incoming.LibraryPathId = library.Paths.Head().Id;
 
-                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
-                    Either<BaseError, bool> refreshResult =
-                        await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingEpisode, localPath);
+                        _logger.LogDebug(
+                            "INSERT: Item id is new for show {Show} season {Season} episode {Episode}",
+                            showName,
+                            seasonName,
+                            incoming.EpisodeMetadata.HeadOrNone().Map(em => em.EpisodeNumber));
 
-                    refreshResult.Match(
-                        _ => { },
-                        error => _logger.LogWarning(
-                            "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                            "Statistics",
-                            localPath,
-                            error.Value));
-                }
+                        if (await _televisionRepository.AddEpisode(season, incoming))
+                        {
+                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { incoming });
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        updateStatistics = false;
+                        _logger.LogError(
+                            ex,
+                            "Error adding episode {Path}",
+                            incoming.MediaVersions.Head().MediaFiles.Head().Path);
+                    }
+                });
+
+            if (updateStatistics)
+            {
+                string localPath = _pathReplacementService.GetReplacementJellyfinPath(
+                    pathReplacements,
+                    incoming.MediaVersions.Head().MediaFiles.Head().Path,
+                    false);
+
+                _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
+                Either<BaseError, bool> refreshResult =
+                    await _localStatisticsProvider.RefreshStatistics(ffprobePath, incomingEpisode, localPath);
+
+                refreshResult.Match(
+                    _ => { },
+                    error => _logger.LogWarning(
+                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                        "Statistics",
+                        localPath,
+                        error.Value));
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Jellyfin/JellyfinUrl.cs b/ErsatzTV.Core/Jellyfin/JellyfinUrl.cs
index dca72ec69..d0eba52e6 100644
--- a/ErsatzTV.Core/Jellyfin/JellyfinUrl.cs
+++ b/ErsatzTV.Core/Jellyfin/JellyfinUrl.cs
@@ -1,84 +1,82 @@
 using ErsatzTV.Core.Domain;
 using Flurl;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Jellyfin
+namespace ErsatzTV.Core.Jellyfin;
+
+public static class JellyfinUrl
 {
-    public static class JellyfinUrl
+    public static Url ForArtwork(Option<JellyfinMediaSource> maybeJellyfin, string artwork)
     {
-        public static Url ForArtwork(Option<JellyfinMediaSource> maybeJellyfin, string artwork)
+        string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
+            .Flatten()
+            .IfNone("jellyfin://");
+
+        string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
+        if (split.Length != 2)
         {
-            string address = maybeJellyfin.Map(ms => ms.Connections.HeadOrNone().Map(c => c.Address))
-                .Flatten()
-                .IfNone("jellyfin://");
-
-            string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
-            if (split.Length != 2)
-            {
-                return artwork;
-            }
-
-            string pathSegment = split[0];
-            QueryParamCollection query = Url.ParseQueryParams(split[1]);
-
-            return Url.Parse(address)
-                .AppendPathSegment(pathSegment)
-                .SetQueryParams(query);
+            return artwork;
         }
 
-        public static Url ForArtwork(string address, string artwork)
-        {
-            string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
-            if (split.Length != 2)
-            {
-                return artwork;
-            }
-
-            string pathSegment = split[0];
-            QueryParamCollection query = Url.ParseQueryParams(split[1]);
-
-            return Url.Parse(address)
-                .AppendPathSegment(pathSegment)
-                .SetQueryParams(query);
-        }
-
-        public static Url ProxyForArtwork(string scheme, string host, string artwork, ArtworkKind artworkKind)
-        {
-            string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
-            if (split.Length != 2)
-            {
-                return artwork;
-            }
-
-            string pathSegment = split[0];
-            QueryParamCollection query = Url.ParseQueryParams(split[1]);
-
-            string artworkFolder = artworkKind switch
-            {
-                ArtworkKind.Thumbnail => "thumbnails",
-                _ => "posters"
-            };
-
-            return Url.Parse($"{scheme}://{host}/iptv/artwork/{artworkFolder}/jellyfin")
-                .AppendPathSegment(pathSegment)
-                .SetQueryParams(query);
-        }
-        
-        public static Url RelativeProxyForArtwork(string artwork)
-        {
-            string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
-            if (split.Length != 2)
-            {
-                return artwork;
-            }
-
-            string pathSegment = split[0];
-            QueryParamCollection query = Url.ParseQueryParams(split[1]);
-
-            return Url.Parse("jellyfin")
-                .AppendPathSegment(pathSegment)
-                .SetQueryParams(query);
-        }
+        string pathSegment = split[0];
+        QueryParamCollection query = Url.ParseQueryParams(split[1]);
 
+        return Url.Parse(address)
+            .AppendPathSegment(pathSegment)
+            .SetQueryParams(query);
     }
-}
+
+    public static Url ForArtwork(string address, string artwork)
+    {
+        string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
+        if (split.Length != 2)
+        {
+            return artwork;
+        }
+
+        string pathSegment = split[0];
+        QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+        return Url.Parse(address)
+            .AppendPathSegment(pathSegment)
+            .SetQueryParams(query);
+    }
+
+    public static Url ProxyForArtwork(string scheme, string host, string artwork, ArtworkKind artworkKind)
+    {
+        string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
+        if (split.Length != 2)
+        {
+            return artwork;
+        }
+
+        string pathSegment = split[0];
+        QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+        string artworkFolder = artworkKind switch
+        {
+            ArtworkKind.Thumbnail => "thumbnails",
+            _ => "posters"
+        };
+
+        return Url.Parse($"{scheme}://{host}/iptv/artwork/{artworkFolder}/jellyfin")
+            .AppendPathSegment(pathSegment)
+            .SetQueryParams(query);
+    }
+        
+    public static Url RelativeProxyForArtwork(string artwork)
+    {
+        string[] split = artwork.Replace("jellyfin://", string.Empty).Split('?');
+        if (split.Length != 2)
+        {
+            return artwork;
+        }
+
+        string pathSegment = split[0];
+        QueryParamCollection query = Url.ParseQueryParams(split[1]);
+
+        return Url.Parse("jellyfin")
+            .AppendPathSegment(pathSegment)
+            .SetQueryParams(query);
+    }
+
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/LanguageExtensions.cs b/ErsatzTV.Core/LanguageExtensions.cs
index 99b0d07f6..9a98a8ab9 100644
--- a/ErsatzTV.Core/LanguageExtensions.cs
+++ b/ErsatzTV.Core/LanguageExtensions.cs
@@ -1,47 +1,42 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
-using LanguageExt;
-using static LanguageExt.Prelude;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Core
+namespace ErsatzTV.Core;
+
+[SuppressMessage("ReSharper", "VSTHRD003")]
+public static class LanguageExtensions
 {
-    [SuppressMessage("ReSharper", "VSTHRD003")]
-    public static class LanguageExtensions
-    {
-        public static Either<BaseError, TR> ToEither<TR>(this Validation<BaseError, TR> validation) =>
-            validation.ToEither().MapLeft(errors => errors.Join());
+    public static Either<BaseError, TR> ToEither<TR>(this Validation<BaseError, TR> validation) =>
+        validation.ToEither().MapLeft(errors => errors.Join());
 
-        public static Task<Either<BaseError, TR>> ToEitherAsync<TR>(this Validation<BaseError, Task<TR>> validation) =>
-            validation.ToEither()
-                .MapLeft(errors => errors.Join())
-                .MapAsync<BaseError, Task<TR>, TR>(e => e);
+    public static Task<Either<BaseError, TR>> ToEitherAsync<TR>(this Validation<BaseError, Task<TR>> validation) =>
+        validation.ToEither()
+            .MapLeft(errors => errors.Join())
+            .MapAsync<BaseError, Task<TR>, TR>(e => e);
 
-        public static Task<Either<BaseError, TR>> Apply<T, TR>(
-            this Validation<BaseError, T> validation,
-            Func<T, Task<TR>> task) =>
-            validation.Match<Task<Either<BaseError, TR>>>(
-                async t => await task(t),
-                error => Task.FromResult(Left<BaseError, TR>(error.Join())));
+    public static Task<Either<BaseError, TR>> Apply<T, TR>(
+        this Validation<BaseError, T> validation,
+        Func<T, Task<TR>> task) =>
+        validation.Match<Task<Either<BaseError, TR>>>(
+            async t => await task(t),
+            error => Task.FromResult(Left<BaseError, TR>(error.Join())));
 
-        public static Task<T> LogFailure<T>(
-            this TryAsync<T> tryAsync,
-            T defaultValue,
-            ILogger logger,
-            string message,
-            params object[] args) =>
-            tryAsync.IfFail(
-                ex =>
-                {
-                    logger.LogError(ex, message, args);
-                    return defaultValue;
-                });
+    public static Task<T> LogFailure<T>(
+        this TryAsync<T> tryAsync,
+        T defaultValue,
+        ILogger logger,
+        string message,
+        params object[] args) =>
+        tryAsync.IfFail(
+            ex =>
+            {
+                logger.LogError(ex, message, args);
+                return defaultValue;
+            });
 
-        public static Task<Unit> LogFailure(
-            this TryAsync<Unit> tryAsync,
-            ILogger logger,
-            string message,
-            params object[] args) => LogFailure(tryAsync, Unit.Default, logger, message, args);
-    }
-}
+    public static Task<Unit> LogFailure(
+        this TryAsync<Unit> tryAsync,
+        ILogger logger,
+        string message,
+        params object[] args) => LogFailure(tryAsync, Unit.Default, logger, message, args);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/MediaSources/RemoteMediaSourceSecrets.cs b/ErsatzTV.Core/MediaSources/RemoteMediaSourceSecrets.cs
index 0368409a6..95488b12f 100644
--- a/ErsatzTV.Core/MediaSources/RemoteMediaSourceSecrets.cs
+++ b/ErsatzTV.Core/MediaSources/RemoteMediaSourceSecrets.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Core.MediaSources
+namespace ErsatzTV.Core.MediaSources;
+
+public class RemoteMediaSourceSecrets
 {
-    public class RemoteMediaSourceSecrets
-    {
-        public string Address { get; set; }
-        public string ApiKey { get; set; }
-    }
-}
+    public string Address { get; set; }
+    public string ApiKey { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/FallbackMetadataProvider.cs b/ErsatzTV.Core/Metadata/FallbackMetadataProvider.cs
index 2d03e366b..1bde3746c 100644
--- a/ErsatzTV.Core/Metadata/FallbackMetadataProvider.cs
+++ b/ErsatzTV.Core/Metadata/FallbackMetadataProvider.cs
@@ -1,343 +1,336 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class FallbackMetadataProvider : IFallbackMetadataProvider
 {
-    public class FallbackMetadataProvider : IFallbackMetadataProvider
+    public ShowMetadata GetFallbackMetadataForShow(string showFolder)
     {
-        public ShowMetadata GetFallbackMetadataForShow(string showFolder)
+        string fileName = Path.GetFileName(showFolder);
+        var metadata = new ShowMetadata
         {
-            string fileName = Path.GetFileName(showFolder);
-            var metadata = new ShowMetadata
-            {
-                MetadataKind = MetadataKind.Fallback,
-                Title = fileName ?? showFolder,
-                Genres = new List<Genre>(),
-                Tags = new List<Tag>(),
-                Studios = new List<Studio>(),
-                Actors = new List<Actor>()
-            };
-            return GetTelevisionShowMetadata(fileName, metadata);
-        }
+            MetadataKind = MetadataKind.Fallback,
+            Title = fileName ?? showFolder,
+            Genres = new List<Genre>(),
+            Tags = new List<Tag>(),
+            Studios = new List<Studio>(),
+            Actors = new List<Actor>()
+        };
+        return GetTelevisionShowMetadata(fileName, metadata);
+    }
 
-        public ArtistMetadata GetFallbackMetadataForArtist(string artistFolder)
+    public ArtistMetadata GetFallbackMetadataForArtist(string artistFolder)
+    {
+        string fileName = Path.GetFileName(artistFolder);
+        return new ArtistMetadata
+            { MetadataKind = MetadataKind.Fallback, Title = fileName ?? artistFolder };
+    }
+
+    public List<EpisodeMetadata> GetFallbackMetadata(Episode episode)
+    {
+        string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
+        string fileName = Path.GetFileName(path);
+        var baseMetadata = new EpisodeMetadata
         {
-            string fileName = Path.GetFileName(artistFolder);
-            return new ArtistMetadata
-                { MetadataKind = MetadataKind.Fallback, Title = fileName ?? artistFolder };
-        }
+            MetadataKind = MetadataKind.Fallback,
+            Title = Path.GetFileNameWithoutExtension(path) ?? path,
+            DateAdded = DateTime.UtcNow,
+            EpisodeNumber = 0,
+            Actors = new List<Actor>(),
+            Artwork = new List<Artwork>(),
+            Directors = new List<Director>(),
+            Genres = new List<Genre>(),
+            Guids = new List<MetadataGuid>(),
+            Studios = new List<Studio>(),
+            Tags = new List<Tag>(),
+            Writers = new List<Writer>()
+        };
+        return fileName != null
+            ? GetEpisodeMetadata(fileName, baseMetadata)
+            : new List<EpisodeMetadata> { baseMetadata };
+    }
 
-        public List<EpisodeMetadata> GetFallbackMetadata(Episode episode)
+    public MovieMetadata GetFallbackMetadata(Movie movie)
+    {
+        string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
+        string fileName = Path.GetFileName(path);
+        var metadata = new MovieMetadata
         {
-            string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
-            string fileName = Path.GetFileName(path);
-            var baseMetadata = new EpisodeMetadata
-            {
-                MetadataKind = MetadataKind.Fallback,
-                Title = Path.GetFileNameWithoutExtension(path) ?? path,
-                DateAdded = DateTime.UtcNow,
-                EpisodeNumber = 0,
-                Actors = new List<Actor>(),
-                Artwork = new List<Artwork>(),
-                Directors = new List<Director>(),
-                Genres = new List<Genre>(),
-                Guids = new List<MetadataGuid>(),
-                Studios = new List<Studio>(),
-                Tags = new List<Tag>(),
-                Writers = new List<Writer>()
-            };
-            return fileName != null
-                ? GetEpisodeMetadata(fileName, baseMetadata)
-                : new List<EpisodeMetadata> { baseMetadata };
-        }
+            MetadataKind = MetadataKind.Fallback,
+            Title = Path.GetFileNameWithoutExtension(path) ?? path,
+            Genres = new List<Genre>(),
+            Tags = new List<Tag>(),
+            Studios = new List<Studio>(),
+            Actors = new List<Actor>(),
+            Directors = new List<Director>(),
+            Writers = new List<Writer>()
+        };
 
-        public MovieMetadata GetFallbackMetadata(Movie movie)
+        return fileName != null ? GetMovieMetadata(fileName, metadata) : metadata;
+    }
+
+    public Option<MusicVideoMetadata> GetFallbackMetadata(MusicVideo musicVideo)
+    {
+        string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
+        string fileName = Path.GetFileName(path);
+        var metadata = new MusicVideoMetadata
         {
-            string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
-            string fileName = Path.GetFileName(path);
-            var metadata = new MovieMetadata
-            {
-                MetadataKind = MetadataKind.Fallback,
-                Title = Path.GetFileNameWithoutExtension(path) ?? path,
-                Genres = new List<Genre>(),
-                Tags = new List<Tag>(),
-                Studios = new List<Studio>(),
-                Actors = new List<Actor>(),
-                Directors = new List<Director>(),
-                Writers = new List<Writer>()
-            };
+            MetadataKind = MetadataKind.Fallback,
+            Title = fileName ?? path
+        };
 
-            return fileName != null ? GetMovieMetadata(fileName, metadata) : metadata;
-        }
-
-        public Option<MusicVideoMetadata> GetFallbackMetadata(MusicVideo musicVideo)
-        {
-            string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
-            string fileName = Path.GetFileName(path);
-            var metadata = new MusicVideoMetadata
-            {
-                MetadataKind = MetadataKind.Fallback,
-                Title = fileName ?? path
-            };
-
-            return GetMusicVideoMetadata(fileName, metadata);
-        }
+        return GetMusicVideoMetadata(fileName, metadata);
+    }
         
-        public Option<OtherVideoMetadata> GetFallbackMetadata(OtherVideo otherVideo)
+    public Option<OtherVideoMetadata> GetFallbackMetadata(OtherVideo otherVideo)
+    {
+        string path = otherVideo.MediaVersions.Head().MediaFiles.Head().Path;
+        string fileName = Path.GetFileNameWithoutExtension(path);
+        var metadata = new OtherVideoMetadata
         {
-            string path = otherVideo.MediaVersions.Head().MediaFiles.Head().Path;
-            string fileName = Path.GetFileNameWithoutExtension(path);
-            var metadata = new OtherVideoMetadata
-            {
-                MetadataKind = MetadataKind.Fallback,
-                Title = fileName ?? path,
-                OtherVideo = otherVideo
-            };
+            MetadataKind = MetadataKind.Fallback,
+            Title = fileName ?? path,
+            OtherVideo = otherVideo
+        };
 
-            return GetOtherVideoMetadata(path, metadata);
-        }
+        return GetOtherVideoMetadata(path, metadata);
+    }
 
-        public Option<SongMetadata> GetFallbackMetadata(Song song)
+    public Option<SongMetadata> GetFallbackMetadata(Song song)
+    {
+        string path = song.MediaVersions.Head().MediaFiles.Head().Path;
+        string fileName = Path.GetFileNameWithoutExtension(path);
+        var metadata = new SongMetadata
         {
-            string path = song.MediaVersions.Head().MediaFiles.Head().Path;
-            string fileName = Path.GetFileNameWithoutExtension(path);
-            var metadata = new SongMetadata
-            {
-                MetadataKind = MetadataKind.Fallback,
-                Title = fileName ?? path,
-                Song = song
-            };
+            MetadataKind = MetadataKind.Fallback,
+            Title = fileName ?? path,
+            Song = song
+        };
 
-            return GetSongMetadata(path, metadata);
-        }
+        return GetSongMetadata(path, metadata);
+    }
 
-        public string GetSortTitle(string title)
+    public string GetSortTitle(string title)
+    {
+        if (string.IsNullOrWhiteSpace(title))
         {
-            if (string.IsNullOrWhiteSpace(title))
-            {
-                return title;
-            }
-
-            if (title.StartsWith("the ", StringComparison.OrdinalIgnoreCase))
-            {
-                return title.Substring(4);
-            }
-
-            if (title.StartsWith("a ", StringComparison.OrdinalIgnoreCase))
-            {
-                return title.Substring(2);
-            }
-
-            if (title.StartsWith("an ", StringComparison.OrdinalIgnoreCase))
-            {
-                return title.Substring(3);
-            }
-
-            if (title.StartsWith("Æ"))
-            {
-                return title.Replace("Æ", "E");
-            }
-
             return title;
         }
 
-        private static List<EpisodeMetadata> GetEpisodeMetadata(string fileName, EpisodeMetadata baseMetadata)
+        if (title.StartsWith("the ", StringComparison.OrdinalIgnoreCase))
         {
-            var result = new List<EpisodeMetadata>();
+            return title.Substring(4);
+        }
 
-            try
+        if (title.StartsWith("a ", StringComparison.OrdinalIgnoreCase))
+        {
+            return title.Substring(2);
+        }
+
+        if (title.StartsWith("an ", StringComparison.OrdinalIgnoreCase))
+        {
+            return title.Substring(3);
+        }
+
+        if (title.StartsWith("Æ"))
+        {
+            return title.Replace("Æ", "E");
+        }
+
+        return title;
+    }
+
+    private static List<EpisodeMetadata> GetEpisodeMetadata(string fileName, EpisodeMetadata baseMetadata)
+    {
+        var result = new List<EpisodeMetadata>();
+
+        try
+        {
+            const string PATTERN = @"[sS]\d+[eE]([e\-\d{1,2}]+)";
+            MatchCollection matches = Regex.Matches(fileName, PATTERN);
+            if (matches.Count > 0)
             {
-                const string PATTERN = @"[sS]\d+[eE]([e\-\d{1,2}]+)";
-                MatchCollection matches = Regex.Matches(fileName, PATTERN);
-                if (matches.Count > 0)
+                foreach (Match match in matches)
                 {
-                    foreach (Match match in matches)
+                    string[] split = match.Groups[1].Value.Replace('e', '-').Split('-');
+                    foreach (string ep in split)
                     {
-                        string[] split = match.Groups[1].Value.Replace('e', '-').Split('-');
-                        foreach (string ep in split)
+                        if (!int.TryParse(ep, out int episodeNumber))
                         {
-                            if (!int.TryParse(ep, out int episodeNumber))
-                            {
-                                continue;
-                            }
-
-                            var metadata = new EpisodeMetadata
-                            {
-                                MetadataKind = MetadataKind.Fallback,
-                                EpisodeNumber = episodeNumber,
-                                DateAdded = baseMetadata.DateAdded,
-                                DateUpdated = baseMetadata.DateAdded,
-                                Title = baseMetadata.Title,
-                                Actors = new List<Actor>(),
-                                Artwork = new List<Artwork>(),
-                                Directors = new List<Director>(),
-                                Genres = new List<Genre>(),
-                                Guids = new List<MetadataGuid>(),
-                                Studios = new List<Studio>(),
-                                Tags = new List<Tag>(),
-                                Writers = new List<Writer>()
-                            };
-
-                            result.Add(metadata);
+                            continue;
                         }
+
+                        var metadata = new EpisodeMetadata
+                        {
+                            MetadataKind = MetadataKind.Fallback,
+                            EpisodeNumber = episodeNumber,
+                            DateAdded = baseMetadata.DateAdded,
+                            DateUpdated = baseMetadata.DateAdded,
+                            Title = baseMetadata.Title,
+                            Actors = new List<Actor>(),
+                            Artwork = new List<Artwork>(),
+                            Directors = new List<Director>(),
+                            Genres = new List<Genre>(),
+                            Guids = new List<MetadataGuid>(),
+                            Studios = new List<Studio>(),
+                            Tags = new List<Tag>(),
+                            Writers = new List<Writer>()
+                        };
+
+                        result.Add(metadata);
                     }
-
-                    return result;
                 }
-            }
-            catch (Exception)
-            {
-                // ignored
-            }
 
-            return result;
+                return result;
+            }
+        }
+        catch (Exception)
+        {
+            // ignored
         }
 
-        private MovieMetadata GetMovieMetadata(string fileName, MovieMetadata metadata)
+        return result;
+    }
+
+    private MovieMetadata GetMovieMetadata(string fileName, MovieMetadata metadata)
+    {
+        try
         {
-            try
+            const string PATTERN = @"^(.*?)[.\(](\d{4})[.\)].*\.\w+$";
+            Match match = Regex.Match(fileName, PATTERN);
+            if (match.Success)
             {
-                const string PATTERN = @"^(.*?)[.\(](\d{4})[.\)].*\.\w+$";
-                Match match = Regex.Match(fileName, PATTERN);
-                if (match.Success)
-                {
-                    metadata.Title = match.Groups[1].Value.Trim();
-                    metadata.Year = int.Parse(match.Groups[2].Value);
-                    metadata.ReleaseDate = new DateTime(int.Parse(match.Groups[2].Value), 1, 1);
-                    metadata.DateUpdated = DateTime.UtcNow;
-                }
-            }
-            catch (Exception)
-            {
-                // ignored
+                metadata.Title = match.Groups[1].Value.Trim();
+                metadata.Year = int.Parse(match.Groups[2].Value);
+                metadata.ReleaseDate = new DateTime(int.Parse(match.Groups[2].Value), 1, 1);
+                metadata.DateUpdated = DateTime.UtcNow;
             }
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+
+        return metadata;
+    }
+
+    private Option<MusicVideoMetadata> GetMusicVideoMetadata(string fileName, MusicVideoMetadata metadata)
+    {
+        try
+        {
+            const string PATTERN = @"^(.*?) - (.*?).\w+$";
+            Match match = Regex.Match(fileName, PATTERN);
+            metadata.Title = match.Success
+                ? match.Groups[2].Value.Trim()
+                : Path.GetFileNameWithoutExtension(fileName);
+            metadata.Genres = new List<Genre>();
+            metadata.Tags = new List<Tag>();
+            metadata.Studios = new List<Studio>();
+            metadata.DateUpdated = DateTime.UtcNow;
 
             return metadata;
         }
-
-        private Option<MusicVideoMetadata> GetMusicVideoMetadata(string fileName, MusicVideoMetadata metadata)
+        catch (Exception)
         {
-            try
-            {
-                const string PATTERN = @"^(.*?) - (.*?).\w+$";
-                Match match = Regex.Match(fileName, PATTERN);
-                metadata.Title = match.Success
-                    ? match.Groups[2].Value.Trim()
-                    : Path.GetFileNameWithoutExtension(fileName);
-                metadata.Genres = new List<Genre>();
-                metadata.Tags = new List<Tag>();
-                metadata.Studios = new List<Studio>();
-                metadata.DateUpdated = DateTime.UtcNow;
-
-                return metadata;
-            }
-            catch (Exception)
-            {
-                return None;
-            }
-        }
-        
-        private Option<OtherVideoMetadata> GetOtherVideoMetadata(string path, OtherVideoMetadata metadata)
-        {
-            try
-            {
-                string folder = Path.GetDirectoryName(path);
-                if (folder == null)
-                {
-                    return None;
-                }
-
-                string libraryPath = metadata.OtherVideo.LibraryPath.Path;
-                string parent = Optional(Directory.GetParent(libraryPath)).Match(
-                    di => di.FullName,
-                    () => libraryPath);
-                
-                string diff = Path.GetRelativePath(parent, folder);
-                
-                var tags = diff.Split(Path.DirectorySeparatorChar)
-                    .Map(t => new Tag { Name = t })
-                    .ToList();
-                
-                metadata.Artwork = new List<Artwork>();
-                metadata.Actors = new List<Actor>();
-                metadata.Genres = new List<Genre>();
-                metadata.Tags = tags;
-                metadata.Studios = new List<Studio>();
-                metadata.DateUpdated = DateTime.UtcNow;
-                metadata.OriginalTitle = Path.GetRelativePath(libraryPath, path);
-
-                return metadata;
-            }
-            catch (Exception)
-            {
-                return None;
-            }
-        }
-        
-        private Option<SongMetadata> GetSongMetadata(string path, SongMetadata metadata)
-        {
-            try
-            {
-                string folder = Path.GetDirectoryName(path);
-                if (folder == null)
-                {
-                    return None;
-                }
-
-                string libraryPath = metadata.Song.LibraryPath.Path;
-                string parent = Optional(Directory.GetParent(libraryPath)).Match(
-                    di => di.FullName,
-                    () => libraryPath);
-                
-                string diff = Path.GetRelativePath(parent, folder);
-                
-                var tags = diff.Split(Path.DirectorySeparatorChar)
-                    .Map(t => new Tag { Name = t })
-                    .ToList();
-                
-                metadata.Artwork = new List<Artwork>();
-                metadata.Actors = new List<Actor>();
-                metadata.Genres = new List<Genre>();
-                metadata.Tags = tags;
-                metadata.Studios = new List<Studio>();
-                metadata.DateUpdated = DateTime.UtcNow;
-                metadata.OriginalTitle = Path.GetRelativePath(libraryPath, path);
-
-                return metadata;
-            }
-            catch (Exception)
-            {
-                return None;
-            }
-        }
-
-        private ShowMetadata GetTelevisionShowMetadata(string fileName, ShowMetadata metadata)
-        {
-            try
-            {
-                const string PATTERN = @"^(.*?)[\s.]+?[.\(](\d{4})[.\)].*$";
-                Match match = Regex.Match(fileName, PATTERN);
-                if (match.Success)
-                {
-                    metadata.Title = match.Groups[1].Value;
-                    metadata.Year = int.Parse(match.Groups[2].Value);
-                    metadata.ReleaseDate = new DateTime(int.Parse(match.Groups[2].Value), 1, 1);
-                    metadata.DateUpdated = DateTime.UtcNow;
-                }
-            }
-            catch (Exception)
-            {
-                // ignored
-            }
-
-            return metadata;
+            return None;
         }
     }
-}
+        
+    private Option<OtherVideoMetadata> GetOtherVideoMetadata(string path, OtherVideoMetadata metadata)
+    {
+        try
+        {
+            string folder = Path.GetDirectoryName(path);
+            if (folder == null)
+            {
+                return None;
+            }
+
+            string libraryPath = metadata.OtherVideo.LibraryPath.Path;
+            string parent = Optional(Directory.GetParent(libraryPath)).Match(
+                di => di.FullName,
+                () => libraryPath);
+                
+            string diff = Path.GetRelativePath(parent, folder);
+                
+            var tags = diff.Split(Path.DirectorySeparatorChar)
+                .Map(t => new Tag { Name = t })
+                .ToList();
+                
+            metadata.Artwork = new List<Artwork>();
+            metadata.Actors = new List<Actor>();
+            metadata.Genres = new List<Genre>();
+            metadata.Tags = tags;
+            metadata.Studios = new List<Studio>();
+            metadata.DateUpdated = DateTime.UtcNow;
+            metadata.OriginalTitle = Path.GetRelativePath(libraryPath, path);
+
+            return metadata;
+        }
+        catch (Exception)
+        {
+            return None;
+        }
+    }
+        
+    private Option<SongMetadata> GetSongMetadata(string path, SongMetadata metadata)
+    {
+        try
+        {
+            string folder = Path.GetDirectoryName(path);
+            if (folder == null)
+            {
+                return None;
+            }
+
+            string libraryPath = metadata.Song.LibraryPath.Path;
+            string parent = Optional(Directory.GetParent(libraryPath)).Match(
+                di => di.FullName,
+                () => libraryPath);
+                
+            string diff = Path.GetRelativePath(parent, folder);
+                
+            var tags = diff.Split(Path.DirectorySeparatorChar)
+                .Map(t => new Tag { Name = t })
+                .ToList();
+                
+            metadata.Artwork = new List<Artwork>();
+            metadata.Actors = new List<Actor>();
+            metadata.Genres = new List<Genre>();
+            metadata.Tags = tags;
+            metadata.Studios = new List<Studio>();
+            metadata.DateUpdated = DateTime.UtcNow;
+            metadata.OriginalTitle = Path.GetRelativePath(libraryPath, path);
+
+            return metadata;
+        }
+        catch (Exception)
+        {
+            return None;
+        }
+    }
+
+    private ShowMetadata GetTelevisionShowMetadata(string fileName, ShowMetadata metadata)
+    {
+        try
+        {
+            const string PATTERN = @"^(.*?)[\s.]+?[.\(](\d{4})[.\)].*$";
+            Match match = Regex.Match(fileName, PATTERN);
+            if (match.Success)
+            {
+                metadata.Title = match.Groups[1].Value;
+                metadata.Year = int.Parse(match.Groups[2].Value);
+                metadata.ReleaseDate = new DateTime(int.Parse(match.Groups[2].Value), 1, 1);
+                metadata.DateUpdated = DateTime.UtcNow;
+            }
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+
+        return metadata;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/FolderEtag.cs b/ErsatzTV.Core/Metadata/FolderEtag.cs
index 5e4d7b0f4..ee7199e37 100644
--- a/ErsatzTV.Core/Metadata/FolderEtag.cs
+++ b/ErsatzTV.Core/Metadata/FolderEtag.cs
@@ -1,62 +1,58 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Cryptography;
+using System.Security.Cryptography;
 using System.Text;
 using ErsatzTV.Core.Interfaces.Metadata;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public static class FolderEtag
 {
-    public static class FolderEtag
+    private static readonly MD5 Crypto = MD5.Create();
+
+    public static string Calculate(string folder, ILocalFileSystem localFileSystem)
     {
-        private static readonly MD5 Crypto = MD5.Create();
+        IEnumerable<string> allFiles = localFileSystem.ListFiles(folder);
 
-        public static string Calculate(string folder, ILocalFileSystem localFileSystem)
+        var sb = new StringBuilder();
+        foreach (string file in allFiles.OrderBy(identity))
         {
-            IEnumerable<string> allFiles = localFileSystem.ListFiles(folder);
-
-            var sb = new StringBuilder();
-            foreach (string file in allFiles.OrderBy(identity))
-            {
-                sb.Append(file);
-                sb.Append(localFileSystem.GetLastWriteTime(file).Ticks);
-            }
-
-            var hash = new StringBuilder();
-            byte[] bytes = Crypto.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()));
-            foreach (byte t in bytes)
-            {
-                hash.Append(t.ToString("x2"));
-            }
-
-            return hash.ToString();
+            sb.Append(file);
+            sb.Append(localFileSystem.GetLastWriteTime(file).Ticks);
         }
-        
-        public static string CalculateWithSubfolders(string folder, ILocalFileSystem localFileSystem)
+
+        var hash = new StringBuilder();
+        byte[] bytes = Crypto.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()));
+        foreach (byte t in bytes)
         {
-            IEnumerable<string> allFiles = localFileSystem.ListFiles(folder);
-
-            var sb = new StringBuilder();
-            foreach (string file in allFiles.OrderBy(identity))
-            {
-                sb.Append(file);
-                sb.Append(localFileSystem.GetLastWriteTime(file).Ticks);
-            }
-
-            foreach (string subfolder in localFileSystem.ListSubdirectories(folder).OrderBy(identity))
-            {
-                sb.Append(subfolder);
-                sb.Append(Calculate(subfolder, localFileSystem));
-            }
-
-            var hash = new StringBuilder();
-            byte[] bytes = Crypto.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()));
-            foreach (byte t in bytes)
-            {
-                hash.Append(t.ToString("x2"));
-            }
-
-            return hash.ToString();
+            hash.Append(t.ToString("x2"));
         }
+
+        return hash.ToString();
     }
-}
+        
+    public static string CalculateWithSubfolders(string folder, ILocalFileSystem localFileSystem)
+    {
+        IEnumerable<string> allFiles = localFileSystem.ListFiles(folder);
+
+        var sb = new StringBuilder();
+        foreach (string file in allFiles.OrderBy(identity))
+        {
+            sb.Append(file);
+            sb.Append(localFileSystem.GetLastWriteTime(file).Ticks);
+        }
+
+        foreach (string subfolder in localFileSystem.ListSubdirectories(folder).OrderBy(identity))
+        {
+            sb.Append(subfolder);
+            sb.Append(Calculate(subfolder, localFileSystem));
+        }
+
+        var hash = new StringBuilder();
+        byte[] bytes = Crypto.ComputeHash(Encoding.UTF8.GetBytes(sb.ToString()));
+        foreach (byte t in bytes)
+        {
+            hash.Append(t.ToString("x2"));
+        }
+
+        return hash.ToString();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/LibraryScanProgress.cs b/ErsatzTV.Core/Metadata/LibraryScanProgress.cs
index 49ae721f2..b6cc8094a 100644
--- a/ErsatzTV.Core/Metadata/LibraryScanProgress.cs
+++ b/ErsatzTV.Core/Metadata/LibraryScanProgress.cs
@@ -1,6 +1,5 @@
 using MediatR;
 
-namespace ErsatzTV.Core.Metadata
-{
-    public record LibraryScanProgress(int LibraryId, decimal Progress) : INotification;
-}
+namespace ErsatzTV.Core.Metadata;
+
+public record LibraryScanProgress(int LibraryId, decimal Progress) : INotification;
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/LocalFileSystem.cs b/ErsatzTV.Core/Metadata/LocalFileSystem.cs
index c59467491..c9fe0645a 100644
--- a/ErsatzTV.Core/Metadata/LocalFileSystem.cs
+++ b/ErsatzTV.Core/Metadata/LocalFileSystem.cs
@@ -1,127 +1,120 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class LocalFileSystem : ILocalFileSystem
 {
-    public class LocalFileSystem : ILocalFileSystem
+    private readonly ILogger<LocalFileSystem> _logger;
+
+    public LocalFileSystem(ILogger<LocalFileSystem> logger)
     {
-        private readonly ILogger<LocalFileSystem> _logger;
+        _logger = logger;
+    }
 
-        public LocalFileSystem(ILogger<LocalFileSystem> logger)
+    public Unit EnsureFolderExists(string folder)
+    {
+        try
         {
-            _logger = logger;
+            if (folder != null && !Directory.Exists(folder))
+            {
+                Directory.CreateDirectory(folder);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to ensure folder exists at {Folder}", folder);
         }
 
-        public Unit EnsureFolderExists(string folder)
+        return Unit.Default;
+    }
+
+    public DateTime GetLastWriteTime(string path) =>
+        Try(File.GetLastWriteTimeUtc(path)).IfFail(() => SystemTime.MinValueUtc);
+
+    public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
+        Directory.Exists(libraryPath.Path);
+
+    public IEnumerable<string> ListSubdirectories(string folder)
+    {
+        if (Directory.Exists(folder))
         {
             try
             {
-                if (folder != null && !Directory.Exists(folder))
-                {
-                    Directory.CreateDirectory(folder);
-                }
+                return Directory.EnumerateDirectories(folder);
             }
-            catch (Exception ex)
+            catch
             {
-                _logger.LogWarning(ex, "Failed to ensure folder exists at {Folder}", folder);
+                // do nothing
             }
+        }
+
+        return new List<string>();
+    }
+
+    public IEnumerable<string> ListFiles(string folder)
+    {
+        if (Directory.Exists(folder))
+        {
+            try
+            {
+                return Directory.EnumerateFiles(folder, "*", SearchOption.TopDirectoryOnly);
+            }
+            catch
+            {
+                // do nothing
+            }
+        }
+
+        return new List<string>();
+    }
+
+    public bool FileExists(string path) => File.Exists(path);
+
+    public bool FolderExists(string folder) => Directory.Exists(folder);
+
+    public async Task<Either<BaseError, Unit>> CopyFile(string source, string destination)
+    {
+        try
+        {
+            string directory = Path.GetDirectoryName(destination) ?? string.Empty;
+            if (!Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            await using FileStream sourceStream = File.OpenRead(source);
+            await using FileStream destinationStream = File.Create(destination);
+            await sourceStream.CopyToAsync(destinationStream);
 
             return Unit.Default;
         }
-
-        public DateTime GetLastWriteTime(string path) =>
-            Try(File.GetLastWriteTimeUtc(path)).IfFail(() => SystemTime.MinValueUtc);
-
-        public bool IsLibraryPathAccessible(LibraryPath libraryPath) =>
-            Directory.Exists(libraryPath.Path);
-
-        public IEnumerable<string> ListSubdirectories(string folder)
+        catch (Exception ex)
         {
-            if (Directory.Exists(folder))
-            {
-                try
-                {
-                    return Directory.EnumerateDirectories(folder);
-                }
-                catch
-                {
-                    // do nothing
-                }
-            }
-
-            return new List<string>();
-        }
-
-        public IEnumerable<string> ListFiles(string folder)
-        {
-            if (Directory.Exists(folder))
-            {
-                try
-                {
-                    return Directory.EnumerateFiles(folder, "*", SearchOption.TopDirectoryOnly);
-                }
-                catch
-                {
-                    // do nothing
-                }
-            }
-
-            return new List<string>();
-        }
-
-        public bool FileExists(string path) => File.Exists(path);
-
-        public bool FolderExists(string folder) => Directory.Exists(folder);
-
-        public async Task<Either<BaseError, Unit>> CopyFile(string source, string destination)
-        {
-            try
-            {
-                string directory = Path.GetDirectoryName(destination) ?? string.Empty;
-                if (!Directory.Exists(directory))
-                {
-                    Directory.CreateDirectory(directory);
-                }
-
-                await using FileStream sourceStream = File.OpenRead(source);
-                await using FileStream destinationStream = File.Create(destination);
-                await sourceStream.CopyToAsync(destinationStream);
-
-                return Unit.Default;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public Unit EmptyFolder(string folder)
-        {
-            try
-            {
-                foreach (string file in Directory.GetFiles(folder))
-                {
-                    File.Delete(file);
-                }
-
-                foreach (string directory in Directory.GetDirectories(folder))
-                {
-                    Directory.Delete(directory, true);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to empty folder at {Folder}", folder);
-            }
-
-            return Unit.Default;
+            return BaseError.New(ex.ToString());
         }
     }
-}
+
+    public Unit EmptyFolder(string folder)
+    {
+        try
+        {
+            foreach (string file in Directory.GetFiles(folder))
+            {
+                File.Delete(file);
+            }
+
+            foreach (string directory in Directory.GetDirectories(folder))
+            {
+                Directory.Delete(directory, true);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to empty folder at {Folder}", folder);
+        }
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/LocalFolderScanner.cs b/ErsatzTV.Core/Metadata/LocalFolderScanner.cs
index 9c62e6336..ccd9c1cd4 100644
--- a/ErsatzTV.Core/Metadata/LocalFolderScanner.cs
+++ b/ErsatzTV.Core/Metadata/LocalFolderScanner.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.FFmpeg;
@@ -11,290 +6,288 @@ using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public abstract class LocalFolderScanner
 {
-    public abstract class LocalFolderScanner
+    public static readonly List<string> VideoFileExtensions = new()
     {
-        public static readonly List<string> VideoFileExtensions = new()
+        ".mpg", ".mp2", ".mpeg", ".mpe", ".mpv", ".ogg", ".mp4",
+        ".m4p", ".m4v", ".avi", ".wmv", ".mov", ".mkv", ".ts", ".webm"
+    };
+
+    public static readonly List<string> AudioFileExtensions = new()
+    {
+        ".aac", ".alac", ".flac", ".mp3", ".m4a", ".wav", ".wma"
+    };
+
+    public static readonly List<string> ImageFileExtensions = new()
+    {
+        "jpg", "jpeg", "png", "gif", "tbn"
+    };
+
+    public static readonly List<string> ExtraFiles = new()
+    {
+        "behindthescenes", "deleted", "featurette",
+        "interview", "scene", "short", "trailer", "other"
+    };
+
+    public static readonly List<string> ExtraDirectories = new List<string>
         {
-            ".mpg", ".mp2", ".mpeg", ".mpe", ".mpv", ".ogg", ".mp4",
-            ".m4p", ".m4v", ".avi", ".wmv", ".mov", ".mkv", ".ts", ".webm"
-        };
-
-        public static readonly List<string> AudioFileExtensions = new()
-        {
-            ".aac", ".alac", ".flac", ".mp3", ".m4a", ".wav", ".wma"
-        };
-
-        public static readonly List<string> ImageFileExtensions = new()
-        {
-            "jpg", "jpeg", "png", "gif", "tbn"
-        };
-
-        public static readonly List<string> ExtraFiles = new()
-        {
-            "behindthescenes", "deleted", "featurette",
-            "interview", "scene", "short", "trailer", "other"
-        };
-
-        public static readonly List<string> ExtraDirectories = new List<string>
-            {
-                "behind the scenes", "deleted scenes", "featurettes",
-                "interviews", "scenes", "shorts", "trailers", "other",
-                "extras", "specials"
-            }
-            .Map(s => $"{Path.DirectorySeparatorChar}{s}{Path.DirectorySeparatorChar}")
-            .ToList();
-
-        private readonly IImageCache _imageCache;
-        private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
-        private readonly ITempFilePool _tempFilePool;
-
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly ILogger _logger;
-        private readonly IMetadataRepository _metadataRepository;
-        private readonly IMediaItemRepository _mediaItemRepository;
-
-        protected LocalFolderScanner(
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            IMetadataRepository metadataRepository,
-            IMediaItemRepository mediaItemRepository,
-            IImageCache imageCache,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory, 
-            ITempFilePool tempFilePool,
-            ILogger logger)
-        {
-            _localFileSystem = localFileSystem;
-            _localStatisticsProvider = localStatisticsProvider;
-            _metadataRepository = metadataRepository;
-            _mediaItemRepository = mediaItemRepository;
-            _imageCache = imageCache;
-            _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
-            _tempFilePool = tempFilePool;
-            _logger = logger;
+            "behind the scenes", "deleted scenes", "featurettes",
+            "interviews", "scenes", "shorts", "trailers", "other",
+            "extras", "specials"
         }
+        .Map(s => $"{Path.DirectorySeparatorChar}{s}{Path.DirectorySeparatorChar}")
+        .ToList();
 
-        protected async Task<Either<BaseError, MediaItemScanResult<T>>> UpdateStatistics<T>(
-            MediaItemScanResult<T> mediaItem,
-            string ffprobePath)
-            where T : MediaItem
+    private readonly IImageCache _imageCache;
+    private readonly IFFmpegProcessServiceFactory _ffmpegProcessServiceFactory;
+    private readonly ITempFilePool _tempFilePool;
+
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalStatisticsProvider _localStatisticsProvider;
+    private readonly ILogger _logger;
+    private readonly IMetadataRepository _metadataRepository;
+    private readonly IMediaItemRepository _mediaItemRepository;
+
+    protected LocalFolderScanner(
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        IMetadataRepository metadataRepository,
+        IMediaItemRepository mediaItemRepository,
+        IImageCache imageCache,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory, 
+        ITempFilePool tempFilePool,
+        ILogger logger)
+    {
+        _localFileSystem = localFileSystem;
+        _localStatisticsProvider = localStatisticsProvider;
+        _metadataRepository = metadataRepository;
+        _mediaItemRepository = mediaItemRepository;
+        _imageCache = imageCache;
+        _ffmpegProcessServiceFactory = ffmpegProcessServiceFactory;
+        _tempFilePool = tempFilePool;
+        _logger = logger;
+    }
+
+    protected async Task<Either<BaseError, MediaItemScanResult<T>>> UpdateStatistics<T>(
+        MediaItemScanResult<T> mediaItem,
+        string ffprobePath)
+        where T : MediaItem
+    {
+        try
+        {
+            MediaVersion version = mediaItem.Item.GetHeadVersion();
+
+            string path = version.MediaFiles.Head().Path;
+
+            if (version.DateUpdated != _localFileSystem.GetLastWriteTime(path) || !version.Streams.Any())
+            {
+                _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", path);
+                Either<BaseError, bool> refreshResult =
+                    await _localStatisticsProvider.RefreshStatistics(ffprobePath, mediaItem.Item);
+                refreshResult.Match(
+                    result =>
+                    {
+                        if (result)
+                        {
+                            mediaItem.IsUpdated = true;
+                        }
+                    },
+                    error =>
+                        _logger.LogWarning(
+                            "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                            "Statistics",
+                            path,
+                            error.Value));
+            }
+
+            return mediaItem;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    protected async Task<bool> RefreshArtwork(
+        string artworkFile,
+        Domain.Metadata metadata,
+        ArtworkKind artworkKind,
+        Option<string> ffmpegPath,
+        Option<int> attachedPicIndex)
+    {
+        DateTime lastWriteTime = _localFileSystem.GetLastWriteTime(artworkFile);
+
+        metadata.Artwork ??= new List<Artwork>();
+
+        Option<Artwork> maybeArtwork = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind);
+
+        bool shouldRefresh = maybeArtwork.Match(
+            artwork => lastWriteTime.Subtract(artwork.DateUpdated) > TimeSpan.FromSeconds(1),
+            true);
+
+        if (shouldRefresh)
         {
             try
             {
-                MediaVersion version = mediaItem.Item.GetHeadVersion();
+                _logger.LogDebug("Refreshing {Attribute} from {Path}", artworkKind, artworkFile);
 
-                string path = version.MediaFiles.Head().Path;
-
-                if (version.DateUpdated != _localFileSystem.GetLastWriteTime(path) || !version.Streams.Any())
-                {
-                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", path);
-                    Either<BaseError, bool> refreshResult =
-                        await _localStatisticsProvider.RefreshStatistics(ffprobePath, mediaItem.Item);
-                    refreshResult.Match(
-                        result =>
-                        {
-                            if (result)
-                            {
-                                mediaItem.IsUpdated = true;
-                            }
-                        },
-                        error =>
-                            _logger.LogWarning(
-                                "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                                "Statistics",
-                                path,
-                                error.Value));
-                }
-
-                return mediaItem;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        protected async Task<bool> RefreshArtwork(
-            string artworkFile,
-            Domain.Metadata metadata,
-            ArtworkKind artworkKind,
-            Option<string> ffmpegPath,
-            Option<int> attachedPicIndex)
-        {
-            DateTime lastWriteTime = _localFileSystem.GetLastWriteTime(artworkFile);
-
-            metadata.Artwork ??= new List<Artwork>();
-
-            Option<Artwork> maybeArtwork = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind);
-
-            bool shouldRefresh = maybeArtwork.Match(
-                artwork => lastWriteTime.Subtract(artwork.DateUpdated) > TimeSpan.FromSeconds(1),
-                true);
-
-            if (shouldRefresh)
-            {
-                try
-                {
-                    _logger.LogDebug("Refreshing {Attribute} from {Path}", artworkKind, artworkFile);
-
-                    string sourcePath = artworkFile;
-                    if (await _metadataRepository.CloneArtwork(
+                string sourcePath = artworkFile;
+                if (await _metadataRepository.CloneArtwork(
                         metadata,
                         maybeArtwork,
                         artworkKind,
                         sourcePath,
                         lastWriteTime))
-                    {
-                        return true;
-                    }
+                {
+                    return true;
+                }
 
-                    // if ffmpeg path is passed, we need pre-processing
-                    foreach (string path in ffmpegPath)
-                    {
-                        IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
+                // if ffmpeg path is passed, we need pre-processing
+                foreach (string path in ffmpegPath)
+                {
+                    IFFmpegProcessService ffmpegProcessService = await _ffmpegProcessServiceFactory.GetService();
                         
-                        artworkFile = await attachedPicIndex.Match(
-                            async picIndex =>
-                            {
-                                // extract attached pic (and convert to png)
-                                string tempName = _tempFilePool.GetNextTempFile(TempFileCategory.CoverArt);
-                                using Process process = ffmpegProcessService.ExtractAttachedPicAsPng(
-                                    path,
-                                    artworkFile,
-                                    picIndex,
-                                    tempName);
-                                process.Start();
-                                await process.WaitForExitAsync();
+                    artworkFile = await attachedPicIndex.Match(
+                        async picIndex =>
+                        {
+                            // extract attached pic (and convert to png)
+                            string tempName = _tempFilePool.GetNextTempFile(TempFileCategory.CoverArt);
+                            using Process process = ffmpegProcessService.ExtractAttachedPicAsPng(
+                                path,
+                                artworkFile,
+                                picIndex,
+                                tempName);
+                            process.Start();
+                            await process.WaitForExitAsync();
 
-                                return tempName;
+                            return tempName;
+                        },
+                        async () =>
+                        {
+                            // no attached pic index means convert to png
+                            string tempName = _tempFilePool.GetNextTempFile(TempFileCategory.CoverArt);
+                            using Process process = ffmpegProcessService.ConvertToPng(path, artworkFile, tempName);
+                            process.Start();
+                            await process.WaitForExitAsync();
+
+                            return tempName;
+                        });
+                }
+
+                Either<BaseError, string> maybeCacheName =
+                    await _imageCache.CopyArtworkToCache(artworkFile, artworkKind);
+
+                return await maybeCacheName.Match(
+                    async cacheName =>
+                    {
+                        await maybeArtwork.Match(
+                            async artwork =>
+                            {
+                                artwork.Path = cacheName;
+                                artwork.SourcePath = sourcePath;
+                                artwork.DateUpdated = lastWriteTime;
+
+                                if (metadata is SongMetadata)
+                                {
+                                    artwork.BlurHash43 = await _imageCache.CalculateBlurHash(
+                                        cacheName,
+                                        artworkKind,
+                                        4,
+                                        3);
+                                    artwork.BlurHash54 = await _imageCache.CalculateBlurHash(
+                                        cacheName,
+                                        artworkKind,
+                                        5,
+                                        4);
+                                    artwork.BlurHash64 = await _imageCache.CalculateBlurHash(
+                                        cacheName,
+                                        artworkKind,
+                                        6,
+                                        4);
+                                }
+
+                                await _metadataRepository.UpdateArtworkPath(artwork);
                             },
                             async () =>
                             {
-                                // no attached pic index means convert to png
-                                string tempName = _tempFilePool.GetNextTempFile(TempFileCategory.CoverArt);
-                                using Process process = ffmpegProcessService.ConvertToPng(path, artworkFile, tempName);
-                                process.Start();
-                                await process.WaitForExitAsync();
+                                var artwork = new Artwork
+                                {
+                                    Path = cacheName,
+                                    SourcePath = sourcePath,
+                                    DateAdded = DateTime.UtcNow,
+                                    DateUpdated = lastWriteTime,
+                                    ArtworkKind = artworkKind
+                                };
 
-                                return tempName;
+                                if (metadata is SongMetadata)
+                                {
+                                    artwork.BlurHash43 = await _imageCache.CalculateBlurHash(
+                                        cacheName,
+                                        artworkKind,
+                                        4,
+                                        3);
+                                    artwork.BlurHash54 = await _imageCache.CalculateBlurHash(
+                                        cacheName,
+                                        artworkKind,
+                                        5,
+                                        4);
+                                    artwork.BlurHash64 = await _imageCache.CalculateBlurHash(
+                                        cacheName,
+                                        artworkKind,
+                                        6,
+                                        4);
+                                }
+
+                                metadata.Artwork.Add(artwork);
+                                await _metadataRepository.AddArtwork(metadata, artwork);
                             });
-                    }
 
-                    Either<BaseError, string> maybeCacheName =
-                        await _imageCache.CopyArtworkToCache(artworkFile, artworkKind);
-
-                    return await maybeCacheName.Match(
-                        async cacheName =>
-                        {
-                            await maybeArtwork.Match(
-                                async artwork =>
-                                {
-                                    artwork.Path = cacheName;
-                                    artwork.SourcePath = sourcePath;
-                                    artwork.DateUpdated = lastWriteTime;
-
-                                    if (metadata is SongMetadata)
-                                    {
-                                        artwork.BlurHash43 = await _imageCache.CalculateBlurHash(
-                                            cacheName,
-                                            artworkKind,
-                                            4,
-                                            3);
-                                        artwork.BlurHash54 = await _imageCache.CalculateBlurHash(
-                                            cacheName,
-                                            artworkKind,
-                                            5,
-                                            4);
-                                        artwork.BlurHash64 = await _imageCache.CalculateBlurHash(
-                                            cacheName,
-                                            artworkKind,
-                                            6,
-                                            4);
-                                    }
-
-                                    await _metadataRepository.UpdateArtworkPath(artwork);
-                                },
-                                async () =>
-                                {
-                                    var artwork = new Artwork
-                                    {
-                                        Path = cacheName,
-                                        SourcePath = sourcePath,
-                                        DateAdded = DateTime.UtcNow,
-                                        DateUpdated = lastWriteTime,
-                                        ArtworkKind = artworkKind
-                                    };
-
-                                    if (metadata is SongMetadata)
-                                    {
-                                        artwork.BlurHash43 = await _imageCache.CalculateBlurHash(
-                                            cacheName,
-                                            artworkKind,
-                                            4,
-                                            3);
-                                        artwork.BlurHash54 = await _imageCache.CalculateBlurHash(
-                                            cacheName,
-                                            artworkKind,
-                                            5,
-                                            4);
-                                        artwork.BlurHash64 = await _imageCache.CalculateBlurHash(
-                                            cacheName,
-                                            artworkKind,
-                                            6,
-                                            4);
-                                    }
-
-                                    metadata.Artwork.Add(artwork);
-                                    await _metadataRepository.AddArtwork(metadata, artwork);
-                                });
-
-                            return true;
-                        },
-                        error =>
-                        {
-                            _logger.LogDebug("Failed to cache artwork from {Path}: {Error}", artworkFile, error.Value);
-                            return Task.FromResult(false);
-                        });
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Error refreshing artwork");
-                }
-            }
-
-            return false;
-        }
-
-        protected Task<List<int>> FlagFileNotFound(LibraryPath libraryPath, string path) =>
-            _mediaItemRepository.FlagFileNotFound(libraryPath, path);
-
-        protected async Task<Either<BaseError, MediaItemScanResult<T>>> FlagNormal<T>(MediaItemScanResult<T> result)
-            where T : MediaItem
-        {
-            try
-            {
-                T mediaItem = result.Item;
-                if (mediaItem.State != MediaItemState.Normal)
-                {
-                    await _mediaItemRepository.FlagNormal(mediaItem);
-                    result.IsUpdated = true;
-                }
-
-                return result;
+                        return true;
+                    },
+                    error =>
+                    {
+                        _logger.LogDebug("Failed to cache artwork from {Path}: {Error}", artworkFile, error.Value);
+                        return Task.FromResult(false);
+                    });
             }
             catch (Exception ex)
             {
-                return BaseError.New(ex.ToString());
+                _logger.LogWarning(ex, "Error refreshing artwork");
             }
         }
 
-        protected bool ShouldIncludeFolder(string folder) =>
-            !Path.GetFileName(folder).StartsWith('.') &&
-            !_localFileSystem.FileExists(Path.Combine(folder, ".etvignore"));
+        return false;
     }
-}
+
+    protected Task<List<int>> FlagFileNotFound(LibraryPath libraryPath, string path) =>
+        _mediaItemRepository.FlagFileNotFound(libraryPath, path);
+
+    protected async Task<Either<BaseError, MediaItemScanResult<T>>> FlagNormal<T>(MediaItemScanResult<T> result)
+        where T : MediaItem
+    {
+        try
+        {
+            T mediaItem = result.Item;
+            if (mediaItem.State != MediaItemState.Normal)
+            {
+                await _mediaItemRepository.FlagNormal(mediaItem);
+                result.IsUpdated = true;
+            }
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    protected bool ShouldIncludeFolder(string folder) =>
+        !Path.GetFileName(folder).StartsWith('.') &&
+        !_localFileSystem.FileExists(Path.Combine(folder, ".etvignore"));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/LocalMetadataProvider.cs b/ErsatzTV.Core/Metadata/LocalMetadataProvider.cs
index 8a4e55958..2b46a3161 100644
--- a/ErsatzTV.Core/Metadata/LocalMetadataProvider.cs
+++ b/ErsatzTV.Core/Metadata/LocalMetadataProvider.cs
@@ -1,429 +1,322 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Metadata.Nfo;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata.Nfo;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class LocalMetadataProvider : ILocalMetadataProvider
 {
-    public class LocalMetadataProvider : ILocalMetadataProvider
+    private static readonly XmlSerializer MovieSerializer = new(typeof(MovieNfo));
+    private static readonly XmlSerializer TvShowSerializer = new(typeof(TvShowNfo));
+    private static readonly XmlSerializer ArtistSerializer = new(typeof(ArtistNfo));
+    private static readonly XmlSerializer MusicVideoSerializer = new(typeof(MusicVideoNfo));
+    private readonly IArtistRepository _artistRepository;
+    private readonly IEpisodeNfoReader _episodeNfoReader;
+    private readonly ILocalStatisticsProvider _localStatisticsProvider;
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILogger<LocalMetadataProvider> _logger;
+
+    private readonly IMetadataRepository _metadataRepository;
+    private readonly IMovieRepository _movieRepository;
+    private readonly IMusicVideoRepository _musicVideoRepository;
+    private readonly IOtherVideoRepository _otherVideoRepository;
+    private readonly ISongRepository _songRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public LocalMetadataProvider(
+        IMetadataRepository metadataRepository,
+        IMovieRepository movieRepository,
+        ITelevisionRepository televisionRepository,
+        IArtistRepository artistRepository,
+        IMusicVideoRepository musicVideoRepository,
+        IOtherVideoRepository otherVideoRepository,
+        ISongRepository songRepository,
+        IFallbackMetadataProvider fallbackMetadataProvider,
+        ILocalFileSystem localFileSystem,
+        IEpisodeNfoReader episodeNfoReader,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILogger<LocalMetadataProvider> logger)
     {
-        private static readonly XmlSerializer MovieSerializer = new(typeof(MovieNfo));
-        private static readonly XmlSerializer TvShowSerializer = new(typeof(TvShowNfo));
-        private static readonly XmlSerializer ArtistSerializer = new(typeof(ArtistNfo));
-        private static readonly XmlSerializer MusicVideoSerializer = new(typeof(MusicVideoNfo));
-        private readonly IArtistRepository _artistRepository;
-        private readonly IEpisodeNfoReader _episodeNfoReader;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILogger<LocalMetadataProvider> _logger;
+        _metadataRepository = metadataRepository;
+        _movieRepository = movieRepository;
+        _televisionRepository = televisionRepository;
+        _artistRepository = artistRepository;
+        _musicVideoRepository = musicVideoRepository;
+        _otherVideoRepository = otherVideoRepository;
+        _songRepository = songRepository;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
+        _localFileSystem = localFileSystem;
+        _episodeNfoReader = episodeNfoReader;
+        _localStatisticsProvider = localStatisticsProvider;
+        _logger = logger;
+    }
 
-        private readonly IMetadataRepository _metadataRepository;
-        private readonly IMovieRepository _movieRepository;
-        private readonly IMusicVideoRepository _musicVideoRepository;
-        private readonly IOtherVideoRepository _otherVideoRepository;
-        private readonly ISongRepository _songRepository;
-        private readonly ITelevisionRepository _televisionRepository;
-
-        public LocalMetadataProvider(
-            IMetadataRepository metadataRepository,
-            IMovieRepository movieRepository,
-            ITelevisionRepository televisionRepository,
-            IArtistRepository artistRepository,
-            IMusicVideoRepository musicVideoRepository,
-            IOtherVideoRepository otherVideoRepository,
-            ISongRepository songRepository,
-            IFallbackMetadataProvider fallbackMetadataProvider,
-            ILocalFileSystem localFileSystem,
-            IEpisodeNfoReader episodeNfoReader,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILogger<LocalMetadataProvider> logger)
+    public async Task<ShowMetadata> GetMetadataForShow(string showFolder)
+    {
+        string nfoFileName = Path.Combine(showFolder, "tvshow.nfo");
+        Option<ShowMetadata> maybeMetadata = None;
+        if (_localFileSystem.FileExists(nfoFileName))
         {
-            _metadataRepository = metadataRepository;
-            _movieRepository = movieRepository;
-            _televisionRepository = televisionRepository;
-            _artistRepository = artistRepository;
-            _musicVideoRepository = musicVideoRepository;
-            _otherVideoRepository = otherVideoRepository;
-            _songRepository = songRepository;
-            _fallbackMetadataProvider = fallbackMetadataProvider;
-            _localFileSystem = localFileSystem;
-            _episodeNfoReader = episodeNfoReader;
-            _localStatisticsProvider = localStatisticsProvider;
-            _logger = logger;
+            maybeMetadata = await LoadTelevisionShowMetadata(nfoFileName);
         }
 
-        public async Task<ShowMetadata> GetMetadataForShow(string showFolder)
-        {
-            string nfoFileName = Path.Combine(showFolder, "tvshow.nfo");
-            Option<ShowMetadata> maybeMetadata = None;
-            if (_localFileSystem.FileExists(nfoFileName))
+        return maybeMetadata.Match(
+            metadata =>
             {
-                maybeMetadata = await LoadTelevisionShowMetadata(nfoFileName);
-            }
-
-            return maybeMetadata.Match(
-                metadata =>
-                {
-                    metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
-                    return metadata;
-                },
-                () =>
-                {
-                    ShowMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder);
-                    metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
-                    return metadata;
-                });
-        }
-
-        public async Task<ArtistMetadata> GetMetadataForArtist(string artistFolder)
-        {
-            string nfoFileName = Path.Combine(artistFolder, "artist.nfo");
-            Option<ArtistMetadata> maybeMetadata = None;
-            if (_localFileSystem.FileExists(nfoFileName))
+                metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
+                return metadata;
+            },
+            () =>
             {
-                maybeMetadata = await LoadArtistMetadata(nfoFileName);
-            }
+                ShowMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder);
+                metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
+                return metadata;
+            });
+    }
 
-            return maybeMetadata.Match(
-                metadata =>
-                {
-                    metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
-                    return metadata;
-                },
-                () =>
-                {
-                    ArtistMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadataForArtist(artistFolder);
-                    metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
-                    return metadata;
-                });
+    public async Task<ArtistMetadata> GetMetadataForArtist(string artistFolder)
+    {
+        string nfoFileName = Path.Combine(artistFolder, "artist.nfo");
+        Option<ArtistMetadata> maybeMetadata = None;
+        if (_localFileSystem.FileExists(nfoFileName))
+        {
+            maybeMetadata = await LoadArtistMetadata(nfoFileName);
         }
 
-        public Task<bool> RefreshSidecarMetadata(Movie movie, string nfoFileName) =>
-            LoadMovieMetadata(movie, nfoFileName).Bind(
-                maybeMetadata => maybeMetadata.Match(
-                    metadata => ApplyMetadataUpdate(movie, metadata),
-                    () => Task.FromResult(false)));
+        return maybeMetadata.Match(
+            metadata =>
+            {
+                metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
+                return metadata;
+            },
+            () =>
+            {
+                ArtistMetadata metadata = _fallbackMetadataProvider.GetFallbackMetadataForArtist(artistFolder);
+                metadata.SortTitle = _fallbackMetadataProvider.GetSortTitle(metadata.Title);
+                return metadata;
+            });
+    }
 
-        public Task<bool> RefreshSidecarMetadata(Show televisionShow, string nfoFileName) =>
-            LoadTelevisionShowMetadata(nfoFileName).Bind(
-                maybeMetadata => maybeMetadata.Match(
-                    metadata => ApplyMetadataUpdate(televisionShow, metadata),
-                    () => Task.FromResult(false)));
+    public Task<bool> RefreshSidecarMetadata(Movie movie, string nfoFileName) =>
+        LoadMovieMetadata(movie, nfoFileName).Bind(
+            maybeMetadata => maybeMetadata.Match(
+                metadata => ApplyMetadataUpdate(movie, metadata),
+                () => Task.FromResult(false)));
 
-        public Task<bool> RefreshSidecarMetadata(Episode episode, string nfoFileName) =>
-            LoadEpisodeMetadata(episode, nfoFileName).Bind(metadata => ApplyMetadataUpdate(episode, metadata));
+    public Task<bool> RefreshSidecarMetadata(Show televisionShow, string nfoFileName) =>
+        LoadTelevisionShowMetadata(nfoFileName).Bind(
+            maybeMetadata => maybeMetadata.Match(
+                metadata => ApplyMetadataUpdate(televisionShow, metadata),
+                () => Task.FromResult(false)));
 
-        public Task<bool> RefreshSidecarMetadata(Artist artist, string nfoFileName) =>
-            LoadArtistMetadata(nfoFileName).Bind(
-                maybeMetadata => maybeMetadata.Match(
-                    metadata => ApplyMetadataUpdate(artist, metadata),
-                    () => Task.FromResult(false)));
+    public Task<bool> RefreshSidecarMetadata(Episode episode, string nfoFileName) =>
+        LoadEpisodeMetadata(episode, nfoFileName).Bind(metadata => ApplyMetadataUpdate(episode, metadata));
 
-        public Task<bool> RefreshSidecarMetadata(MusicVideo musicVideo, string nfoFileName) =>
-            LoadMusicVideoMetadata(nfoFileName).Bind(
-                maybeMetadata => maybeMetadata.Match(
-                    metadata => ApplyMetadataUpdate(musicVideo, metadata),
-                    () => RefreshFallbackMetadata(musicVideo)));
+    public Task<bool> RefreshSidecarMetadata(Artist artist, string nfoFileName) =>
+        LoadArtistMetadata(nfoFileName).Bind(
+            maybeMetadata => maybeMetadata.Match(
+                metadata => ApplyMetadataUpdate(artist, metadata),
+                () => Task.FromResult(false)));
 
-        public Task<bool> RefreshTagMetadata(Song song, string ffprobePath) =>
-            LoadSongMetadata(song, ffprobePath).Bind(
-                maybeMetadata => maybeMetadata.Match(
-                    metadata => ApplyMetadataUpdate(song, metadata),
-                    () => RefreshFallbackMetadata(song)));
-
-        public Task<bool> RefreshFallbackMetadata(Movie movie) =>
-            ApplyMetadataUpdate(movie, _fallbackMetadataProvider.GetFallbackMetadata(movie));
-
-        public Task<bool> RefreshFallbackMetadata(Episode episode) =>
-            ApplyMetadataUpdate(episode, _fallbackMetadataProvider.GetFallbackMetadata(episode));
-
-        public Task<bool> RefreshFallbackMetadata(Artist artist, string artistFolder) =>
-            ApplyMetadataUpdate(artist, _fallbackMetadataProvider.GetFallbackMetadataForArtist(artistFolder));
-
-        public Task<bool> RefreshFallbackMetadata(OtherVideo otherVideo) =>
-            _fallbackMetadataProvider.GetFallbackMetadata(otherVideo).Match(
-                metadata => ApplyMetadataUpdate(otherVideo, metadata),
-                () => Task.FromResult(false));
-
-        public Task<bool> RefreshFallbackMetadata(Song song) =>
-            _fallbackMetadataProvider.GetFallbackMetadata(song).Match(
-                metadata => ApplyMetadataUpdate(song, metadata),
-                () => Task.FromResult(false));
-
-        public Task<bool> RefreshFallbackMetadata(MusicVideo musicVideo) =>
-            _fallbackMetadataProvider.GetFallbackMetadata(musicVideo).Match(
+    public Task<bool> RefreshSidecarMetadata(MusicVideo musicVideo, string nfoFileName) =>
+        LoadMusicVideoMetadata(nfoFileName).Bind(
+            maybeMetadata => maybeMetadata.Match(
                 metadata => ApplyMetadataUpdate(musicVideo, metadata),
-                () => Task.FromResult(false));
+                () => RefreshFallbackMetadata(musicVideo)));
 
-        public Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder) =>
-            ApplyMetadataUpdate(televisionShow, _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder));
+    public Task<bool> RefreshTagMetadata(Song song, string ffprobePath) =>
+        LoadSongMetadata(song, ffprobePath).Bind(
+            maybeMetadata => maybeMetadata.Match(
+                metadata => ApplyMetadataUpdate(song, metadata),
+                () => RefreshFallbackMetadata(song)));
 
-        private async Task<Option<MusicVideoMetadata>> LoadMusicVideoMetadata(string nfoFileName)
+    public Task<bool> RefreshFallbackMetadata(Movie movie) =>
+        ApplyMetadataUpdate(movie, _fallbackMetadataProvider.GetFallbackMetadata(movie));
+
+    public Task<bool> RefreshFallbackMetadata(Episode episode) =>
+        ApplyMetadataUpdate(episode, _fallbackMetadataProvider.GetFallbackMetadata(episode));
+
+    public Task<bool> RefreshFallbackMetadata(Artist artist, string artistFolder) =>
+        ApplyMetadataUpdate(artist, _fallbackMetadataProvider.GetFallbackMetadataForArtist(artistFolder));
+
+    public Task<bool> RefreshFallbackMetadata(OtherVideo otherVideo) =>
+        _fallbackMetadataProvider.GetFallbackMetadata(otherVideo).Match(
+            metadata => ApplyMetadataUpdate(otherVideo, metadata),
+            () => Task.FromResult(false));
+
+    public Task<bool> RefreshFallbackMetadata(Song song) =>
+        _fallbackMetadataProvider.GetFallbackMetadata(song).Match(
+            metadata => ApplyMetadataUpdate(song, metadata),
+            () => Task.FromResult(false));
+
+    public Task<bool> RefreshFallbackMetadata(MusicVideo musicVideo) =>
+        _fallbackMetadataProvider.GetFallbackMetadata(musicVideo).Match(
+            metadata => ApplyMetadataUpdate(musicVideo, metadata),
+            () => Task.FromResult(false));
+
+    public Task<bool> RefreshFallbackMetadata(Show televisionShow, string showFolder) =>
+        ApplyMetadataUpdate(televisionShow, _fallbackMetadataProvider.GetFallbackMetadataForShow(showFolder));
+
+    private async Task<Option<MusicVideoMetadata>> LoadMusicVideoMetadata(string nfoFileName)
+    {
+        try
         {
-            try
-            {
-                await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
-                Option<MusicVideoNfo> maybeNfo = MusicVideoSerializer.Deserialize(fileStream) as MusicVideoNfo;
-                return maybeNfo.Match<Option<MusicVideoMetadata>>(
-                    nfo => new MusicVideoMetadata
-                    {
-                        MetadataKind = MetadataKind.Sidecar,
-                        DateAdded = DateTime.UtcNow,
-                        DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
-                        Album = nfo.Album,
-                        Title = nfo.Title,
-                        Plot = nfo.Plot,
-                        Year = GetYear(nfo.Year, nfo.Premiered),
-                        ReleaseDate = GetAired(nfo.Year, nfo.Premiered),
-                        Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
-                        Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
-                        Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList()
-                    },
-                    None);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogInformation(ex, "Failed to read music video nfo metadata from {Path}", nfoFileName);
-                return None;
-            }
-        }
-
-        private async Task<Option<SongMetadata>> LoadSongMetadata(Song song, string ffprobePath)
-        {
-            string path = song.GetHeadVersion().MediaFiles.Head().Path;
-
-            try
-            {
-                Either<BaseError, Dictionary<string, string>> maybeTags =
-                    await _localStatisticsProvider.GetFormatTags(ffprobePath, song);
-
-                return maybeTags.Match(
-                    tags =>
-                    {
-                        Option<SongMetadata> maybeFallbackMetadata =
-                            _fallbackMetadataProvider.GetFallbackMetadata(song);
-                        
-                        var result = new SongMetadata
-                        {
-                            MetadataKind = MetadataKind.Embedded,
-                            DateAdded = DateTime.UtcNow,
-                            DateUpdated = File.GetLastWriteTimeUtc(path),
-                            
-                            Artwork = new List<Artwork>(),
-                            Actors = new List<Actor>(),
-                            Genres = new List<Genre>(),
-                            Studios = new List<Studio>(),
-                            Tags = new List<Tag>()
-                        };
-                        
-                        if (tags.TryGetValue(MetadataFormatTag.Album, out string album))
-                        {
-                            result.Album = album;
-                        }
-
-                        if (tags.TryGetValue(MetadataFormatTag.Artist, out string artist))
-                        {
-                            result.Artist = artist;
-                        }
-
-                        if (tags.TryGetValue(MetadataFormatTag.Date, out string date))
-                        {
-                            result.Date = date;
-                        }
-
-                        if (tags.TryGetValue(MetadataFormatTag.Genre, out string genre))
-                        {
-                            result.Genres.AddRange(SplitGenres(genre).Map(n => new Genre { Name = n }));
-                        }
-
-                        if (tags.TryGetValue(MetadataFormatTag.Title, out string title))
-                        {
-                            result.Title = title;
-                        }
-
-                        if (tags.TryGetValue(MetadataFormatTag.Track, out string track))
-                        {
-                            result.Track = track;
-                        }
-
-                        foreach (SongMetadata fallbackMetadata in maybeFallbackMetadata)
-                        {
-                            if (string.IsNullOrWhiteSpace(result.Title))
-                            {
-                                result.Title = fallbackMetadata.Title;
-                            }
-
-                            result.OriginalTitle = fallbackMetadata.OriginalTitle;
-
-                            // preserve folder tagging - maybe someone uses this
-                            foreach (Tag tag in fallbackMetadata.Tags)
-                            {
-                                result.Tags.Add(tag);
-                            }
-                        }
-
-                        return result;
-                    },
-                    _ => Option<SongMetadata>.None);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogInformation(ex, "Failed to read embedded song metadata from {Path}", path);
-                return None;
-            }
-        }
-
-        private async Task<bool> ApplyMetadataUpdate(Episode episode, List<EpisodeMetadata> episodeMetadata)
-        {
-            var updated = false;
-
-            episode.EpisodeMetadata ??= new List<EpisodeMetadata>();
-
-            var toUpdate = episode.EpisodeMetadata
-                .Where(em => episodeMetadata.Any(em2 => em2.EpisodeNumber == em.EpisodeNumber))
-                .ToList();
-            var toRemove = episode.EpisodeMetadata.Except(toUpdate).ToList();
-            var toAdd = episodeMetadata
-                .Where(em => episode.EpisodeMetadata.All(em2 => em2.EpisodeNumber != em.EpisodeNumber))
-                .ToList();
-
-            foreach (EpisodeMetadata metadata in toRemove)
-            {
-                await _televisionRepository.RemoveMetadata(episode, metadata);
-                updated = true;
-            }
-
-            foreach (EpisodeMetadata metadata in toAdd)
-            {
-                metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                    : metadata.SortTitle;
-                metadata.EpisodeId = episode.Id;
-                metadata.Episode = episode;
-                episode.EpisodeMetadata.Add(metadata);
-
-                updated = await _metadataRepository.Add(metadata) || updated;
-            }
-
-            foreach (EpisodeMetadata existing in toUpdate)
-            {
-                Option<EpisodeMetadata> maybeIncoming =
-                    episodeMetadata.Find(em => em.EpisodeNumber == existing.EpisodeNumber);
-                updated = await maybeIncoming.Match(
-                    async metadata =>
-                    {
-                        existing.Outline = metadata.Outline;
-                        existing.Plot = metadata.Plot;
-                        existing.Tagline = metadata.Tagline;
-                        existing.Title = metadata.Title;
-
-                        if (existing.DateAdded == SystemTime.MinValueUtc)
-                        {
-                            existing.DateAdded = metadata.DateAdded;
-                        }
-
-                        existing.DateUpdated = metadata.DateUpdated;
-                        existing.MetadataKind = metadata.MetadataKind;
-                        existing.OriginalTitle = metadata.OriginalTitle;
-                        existing.ReleaseDate = metadata.ReleaseDate;
-                        existing.Year = metadata.Year;
-                        existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                            ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                            : metadata.SortTitle;
-
-                        updated = await UpdateMetadataCollections(
-                            existing,
-                            metadata,
-                            (_, _) => Task.FromResult(false),
-                            (_, _) => Task.FromResult(false),
-                            (_, _) => Task.FromResult(false),
-                            _televisionRepository.AddActor) || updated;
-
-                        foreach (Director director in existing.Directors
-                            .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name)).ToList())
-                        {
-                            existing.Directors.Remove(director);
-                            if (await _metadataRepository.RemoveDirector(director))
-                            {
-                                updated = true;
-                            }
-                        }
-
-                        foreach (Director director in metadata.Directors
-                            .Filter(d => existing.Directors.All(d2 => d2.Name != d.Name)).ToList())
-                        {
-                            existing.Directors.Add(director);
-                            if (await _televisionRepository.AddDirector(existing, director))
-                            {
-                                updated = true;
-                            }
-                        }
-
-                        foreach (Writer writer in existing.Writers
-                            .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name)).ToList())
-                        {
-                            existing.Writers.Remove(writer);
-                            if (await _metadataRepository.RemoveWriter(writer))
-                            {
-                                updated = true;
-                            }
-                        }
-
-                        foreach (Writer writer in metadata.Writers
-                            .Filter(w => existing.Writers.All(w2 => w2.Name != w.Name)).ToList())
-                        {
-                            existing.Writers.Add(writer);
-                            if (await _televisionRepository.AddWriter(existing, writer))
-                            {
-                                updated = true;
-                            }
-                        }
-
-                        foreach (MetadataGuid guid in existing.Guids
-                            .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
-                        {
-                            existing.Guids.Remove(guid);
-                            if (await _metadataRepository.RemoveGuid(guid))
-                            {
-                                updated = true;
-                            }
-                        }
-
-                        foreach (MetadataGuid guid in metadata.Guids
-                            .Filter(g => existing.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
-                        {
-                            existing.Guids.Add(guid);
-                            if (await _metadataRepository.AddGuid(existing, guid))
-                            {
-                                updated = true;
-                            }
-                        }
-
-                        return await _metadataRepository.Update(existing) || updated;
-                    },
-                    () => Task.FromResult(updated)) || updated;
-            }
-
-            return updated;
-        }
-
-        private Task<bool> ApplyMetadataUpdate(Movie movie, MovieMetadata metadata) =>
-            Optional(movie.MovieMetadata).Flatten().HeadOrNone().Match(
-                async existing =>
+            await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
+            Option<MusicVideoNfo> maybeNfo = MusicVideoSerializer.Deserialize(fileStream) as MusicVideoNfo;
+            return maybeNfo.Match<Option<MusicVideoMetadata>>(
+                nfo => new MusicVideoMetadata
+                {
+                    MetadataKind = MetadataKind.Sidecar,
+                    DateAdded = DateTime.UtcNow,
+                    DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
+                    Album = nfo.Album,
+                    Title = nfo.Title,
+                    Plot = nfo.Plot,
+                    Year = GetYear(nfo.Year, nfo.Premiered),
+                    ReleaseDate = GetAired(nfo.Year, nfo.Premiered),
+                    Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
+                    Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
+                    Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList()
+                },
+                None);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogInformation(ex, "Failed to read music video nfo metadata from {Path}", nfoFileName);
+            return None;
+        }
+    }
+
+    private async Task<Option<SongMetadata>> LoadSongMetadata(Song song, string ffprobePath)
+    {
+        string path = song.GetHeadVersion().MediaFiles.Head().Path;
+
+        try
+        {
+            Either<BaseError, Dictionary<string, string>> maybeTags =
+                await _localStatisticsProvider.GetFormatTags(ffprobePath, song);
+
+            return maybeTags.Match(
+                tags =>
+                {
+                    Option<SongMetadata> maybeFallbackMetadata =
+                        _fallbackMetadataProvider.GetFallbackMetadata(song);
+                        
+                    var result = new SongMetadata
+                    {
+                        MetadataKind = MetadataKind.Embedded,
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = File.GetLastWriteTimeUtc(path),
+                            
+                        Artwork = new List<Artwork>(),
+                        Actors = new List<Actor>(),
+                        Genres = new List<Genre>(),
+                        Studios = new List<Studio>(),
+                        Tags = new List<Tag>()
+                    };
+                        
+                    if (tags.TryGetValue(MetadataFormatTag.Album, out string album))
+                    {
+                        result.Album = album;
+                    }
+
+                    if (tags.TryGetValue(MetadataFormatTag.Artist, out string artist))
+                    {
+                        result.Artist = artist;
+                    }
+
+                    if (tags.TryGetValue(MetadataFormatTag.Date, out string date))
+                    {
+                        result.Date = date;
+                    }
+
+                    if (tags.TryGetValue(MetadataFormatTag.Genre, out string genre))
+                    {
+                        result.Genres.AddRange(SplitGenres(genre).Map(n => new Genre { Name = n }));
+                    }
+
+                    if (tags.TryGetValue(MetadataFormatTag.Title, out string title))
+                    {
+                        result.Title = title;
+                    }
+
+                    if (tags.TryGetValue(MetadataFormatTag.Track, out string track))
+                    {
+                        result.Track = track;
+                    }
+
+                    foreach (SongMetadata fallbackMetadata in maybeFallbackMetadata)
+                    {
+                        if (string.IsNullOrWhiteSpace(result.Title))
+                        {
+                            result.Title = fallbackMetadata.Title;
+                        }
+
+                        result.OriginalTitle = fallbackMetadata.OriginalTitle;
+
+                        // preserve folder tagging - maybe someone uses this
+                        foreach (Tag tag in fallbackMetadata.Tags)
+                        {
+                            result.Tags.Add(tag);
+                        }
+                    }
+
+                    return result;
+                },
+                _ => Option<SongMetadata>.None);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogInformation(ex, "Failed to read embedded song metadata from {Path}", path);
+            return None;
+        }
+    }
+
+    private async Task<bool> ApplyMetadataUpdate(Episode episode, List<EpisodeMetadata> episodeMetadata)
+    {
+        var updated = false;
+
+        episode.EpisodeMetadata ??= new List<EpisodeMetadata>();
+
+        var toUpdate = episode.EpisodeMetadata
+            .Where(em => episodeMetadata.Any(em2 => em2.EpisodeNumber == em.EpisodeNumber))
+            .ToList();
+        var toRemove = episode.EpisodeMetadata.Except(toUpdate).ToList();
+        var toAdd = episodeMetadata
+            .Where(em => episode.EpisodeMetadata.All(em2 => em2.EpisodeNumber != em.EpisodeNumber))
+            .ToList();
+
+        foreach (EpisodeMetadata metadata in toRemove)
+        {
+            await _televisionRepository.RemoveMetadata(episode, metadata);
+            updated = true;
+        }
+
+        foreach (EpisodeMetadata metadata in toAdd)
+        {
+            metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                : metadata.SortTitle;
+            metadata.EpisodeId = episode.Id;
+            metadata.Episode = episode;
+            episode.EpisodeMetadata.Add(metadata);
+
+            updated = await _metadataRepository.Add(metadata) || updated;
+        }
+
+        foreach (EpisodeMetadata existing in toUpdate)
+        {
+            Option<EpisodeMetadata> maybeIncoming =
+                episodeMetadata.Find(em => em.EpisodeNumber == existing.EpisodeNumber);
+            updated = await maybeIncoming.Match(
+                async metadata =>
                 {
-                    existing.ContentRating = metadata.ContentRating;
                     existing.Outline = metadata.Outline;
                     existing.Plot = metadata.Plot;
                     existing.Tagline = metadata.Tagline;
@@ -443,16 +336,16 @@ namespace ErsatzTV.Core.Metadata
                         ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
                         : metadata.SortTitle;
 
-                    bool updated = await UpdateMetadataCollections(
+                    updated = await UpdateMetadataCollections(
                         existing,
                         metadata,
-                        _movieRepository.AddGenre,
-                        _movieRepository.AddTag,
-                        _movieRepository.AddStudio,
-                        _movieRepository.AddActor);
+                        (_, _) => Task.FromResult(false),
+                        (_, _) => Task.FromResult(false),
+                        (_, _) => Task.FromResult(false),
+                        _televisionRepository.AddActor) || updated;
 
                     foreach (Director director in existing.Directors
-                        .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name)).ToList())
+                                 .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name)).ToList())
                     {
                         existing.Directors.Remove(director);
                         if (await _metadataRepository.RemoveDirector(director))
@@ -462,17 +355,17 @@ namespace ErsatzTV.Core.Metadata
                     }
 
                     foreach (Director director in metadata.Directors
-                        .Filter(d => existing.Directors.All(d2 => d2.Name != d.Name)).ToList())
+                                 .Filter(d => existing.Directors.All(d2 => d2.Name != d.Name)).ToList())
                     {
                         existing.Directors.Add(director);
-                        if (await _movieRepository.AddDirector(existing, director))
+                        if (await _televisionRepository.AddDirector(existing, director))
                         {
                             updated = true;
                         }
                     }
 
                     foreach (Writer writer in existing.Writers
-                        .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name)).ToList())
+                                 .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name)).ToList())
                     {
                         existing.Writers.Remove(writer);
                         if (await _metadataRepository.RemoveWriter(writer))
@@ -482,17 +375,17 @@ namespace ErsatzTV.Core.Metadata
                     }
 
                     foreach (Writer writer in metadata.Writers
-                        .Filter(w => existing.Writers.All(w2 => w2.Name != w.Name)).ToList())
+                                 .Filter(w => existing.Writers.All(w2 => w2.Name != w.Name)).ToList())
                     {
                         existing.Writers.Add(writer);
-                        if (await _movieRepository.AddWriter(existing, writer))
+                        if (await _televisionRepository.AddWriter(existing, writer))
                         {
                             updated = true;
                         }
                     }
 
                     foreach (MetadataGuid guid in existing.Guids
-                        .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
+                                 .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
                     {
                         existing.Guids.Remove(guid);
                         if (await _metadataRepository.RemoveGuid(guid))
@@ -502,7 +395,7 @@ namespace ErsatzTV.Core.Metadata
                     }
 
                     foreach (MetadataGuid guid in metadata.Guids
-                        .Filter(g => existing.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
+                                 .Filter(g => existing.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
                     {
                         existing.Guids.Add(guid);
                         if (await _metadataRepository.AddGuid(existing, guid))
@@ -513,509 +406,205 @@ namespace ErsatzTV.Core.Metadata
 
                     return await _metadataRepository.Update(existing) || updated;
                 },
-                async () =>
-                {
-                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-                    metadata.MovieId = movie.Id;
-                    movie.MovieMetadata = new List<MovieMetadata> { metadata };
-
-                    return await _metadataRepository.Add(metadata);
-                });
-
-        private Task<bool> ApplyMetadataUpdate(Show show, ShowMetadata metadata) =>
-            Optional(show.ShowMetadata).Flatten().HeadOrNone().Match(
-                async existing =>
-                {
-                    existing.ContentRating = metadata.ContentRating;
-                    existing.Outline = metadata.Outline;
-                    existing.Plot = metadata.Plot;
-                    existing.Tagline = metadata.Tagline;
-                    existing.Title = metadata.Title;
-
-                    if (existing.DateAdded == SystemTime.MinValueUtc)
-                    {
-                        existing.DateAdded = metadata.DateAdded;
-                    }
-
-                    existing.DateUpdated = metadata.DateUpdated;
-                    existing.MetadataKind = metadata.MetadataKind;
-                    existing.OriginalTitle = metadata.OriginalTitle;
-                    existing.ReleaseDate = metadata.ReleaseDate;
-                    existing.Year = metadata.Year;
-                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-
-                    bool updated = await UpdateMetadataCollections(
-                        existing,
-                        metadata,
-                        _televisionRepository.AddGenre,
-                        _televisionRepository.AddTag,
-                        _televisionRepository.AddStudio,
-                        _televisionRepository.AddActor);
-
-                    foreach (MetadataGuid guid in existing.Guids
-                        .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
-                    {
-                        existing.Guids.Remove(guid);
-                        if (await _metadataRepository.RemoveGuid(guid))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (MetadataGuid guid in metadata.Guids
-                        .Filter(g => existing.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
-                    {
-                        existing.Guids.Add(guid);
-                        if (await _metadataRepository.AddGuid(existing, guid))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    return await _metadataRepository.Update(existing) || updated;
-                },
-                async () =>
-                {
-                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-                    metadata.ShowId = show.Id;
-                    show.ShowMetadata = new List<ShowMetadata> { metadata };
-
-                    return await _metadataRepository.Add(metadata);
-                });
-
-        private Task<bool> ApplyMetadataUpdate(Artist artist, ArtistMetadata metadata) =>
-            Optional(artist.ArtistMetadata).Flatten().HeadOrNone().Match(
-                async existing =>
-                {
-                    existing.Title = metadata.Title;
-                    existing.Disambiguation = metadata.Disambiguation;
-                    existing.Biography = metadata.Biography;
-
-                    if (existing.DateAdded == SystemTime.MinValueUtc)
-                    {
-                        existing.DateAdded = metadata.DateAdded;
-                    }
-
-                    existing.DateUpdated = metadata.DateUpdated;
-                    existing.MetadataKind = metadata.MetadataKind;
-                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-
-                    var updated = false;
-
-                    foreach (Genre genre in existing.Genres.Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
-                        .ToList())
-                    {
-                        existing.Genres.Remove(genre);
-                        if (await _metadataRepository.RemoveGenre(genre))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Genre genre in metadata.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
-                        .ToList())
-                    {
-                        existing.Genres.Add(genre);
-                        if (await _artistRepository.AddGenre(existing, genre))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Style style in existing.Styles.Filter(s => metadata.Styles.All(s2 => s2.Name != s.Name))
-                        .ToList())
-                    {
-                        existing.Styles.Remove(style);
-                        if (await _metadataRepository.RemoveStyle(style))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Style style in metadata.Styles.Filter(s => existing.Styles.All(s2 => s2.Name != s.Name))
-                        .ToList())
-                    {
-                        existing.Styles.Add(style);
-                        if (await _artistRepository.AddStyle(existing, style))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Mood mood in existing.Moods.Filter(m => metadata.Moods.All(m2 => m2.Name != m.Name))
-                        .ToList())
-                    {
-                        existing.Moods.Remove(mood);
-                        if (await _metadataRepository.RemoveMood(mood))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    foreach (Mood mood in metadata.Moods.Filter(s => existing.Moods.All(m2 => m2.Name != s.Name))
-                        .ToList())
-                    {
-                        existing.Moods.Add(mood);
-                        if (await _artistRepository.AddMood(existing, mood))
-                        {
-                            updated = true;
-                        }
-                    }
-
-                    return await _metadataRepository.Update(existing) || updated;
-                },
-                async () =>
-                {
-                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-                    metadata.ArtistId = artist.Id;
-                    artist.ArtistMetadata = new List<ArtistMetadata> { metadata };
-
-                    return await _metadataRepository.Add(metadata);
-                });
-
-        private Task<bool> ApplyMetadataUpdate(MusicVideo musicVideo, MusicVideoMetadata metadata) =>
-            Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone().Match(
-                async existing =>
-                {
-                    existing.Title = metadata.Title;
-                    existing.Year = metadata.Year;
-                    existing.Plot = metadata.Plot;
-                    existing.Album = metadata.Album;
-
-                    if (existing.DateAdded == SystemTime.MinValueUtc)
-                    {
-                        existing.DateAdded = metadata.DateAdded;
-                    }
-
-                    existing.DateUpdated = metadata.DateUpdated;
-                    existing.MetadataKind = metadata.MetadataKind;
-                    existing.OriginalTitle = metadata.OriginalTitle;
-                    existing.ReleaseDate = metadata.ReleaseDate;
-                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-
-                    bool updated = await UpdateMetadataCollections(
-                        existing,
-                        metadata,
-                        _musicVideoRepository.AddGenre,
-                        _musicVideoRepository.AddTag,
-                        _musicVideoRepository.AddStudio,
-                        (_, _) => Task.FromResult(false));
-
-                    return await _metadataRepository.Update(existing) || updated;
-                },
-                async () =>
-                {
-                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-                    metadata.MusicVideoId = musicVideo.Id;
-                    musicVideo.MusicVideoMetadata = new List<MusicVideoMetadata> { metadata };
-
-                    return await _metadataRepository.Add(metadata);
-                });
-        
-        private Task<bool> ApplyMetadataUpdate(OtherVideo otherVideo, OtherVideoMetadata metadata) =>
-            Optional(otherVideo.OtherVideoMetadata).Flatten().HeadOrNone().Match(
-                async existing =>
-                {
-                    existing.Title = metadata.Title;
-
-                    if (existing.DateAdded == SystemTime.MinValueUtc)
-                    {
-                        existing.DateAdded = metadata.DateAdded;
-                    }
-
-                    existing.DateUpdated = metadata.DateUpdated;
-                    existing.MetadataKind = metadata.MetadataKind;
-                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-                    existing.OriginalTitle = metadata.OriginalTitle;
-
-                    bool updated = await UpdateMetadataCollections(
-                        existing,
-                        metadata,
-                        (_, _) => Task.FromResult(false),
-                        _otherVideoRepository.AddTag,
-                        (_, _) => Task.FromResult(false),
-                        (_, _) => Task.FromResult(false));
-
-                    return await _metadataRepository.Update(existing) || updated;
-                },
-                async () =>
-                {
-                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-                    metadata.OtherVideoId = otherVideo.Id;
-                    otherVideo.OtherVideoMetadata = new List<OtherVideoMetadata> { metadata };
-
-                    return await _metadataRepository.Add(metadata);
-                });
-        
-        private Task<bool> ApplyMetadataUpdate(Song song, SongMetadata metadata) =>
-            Optional(song.SongMetadata).Flatten().HeadOrNone().Match(
-                async existing =>
-                {
-                    existing.Title = metadata.Title;
-                    existing.Artist = metadata.Artist;
-                    existing.Album = metadata.Album;
-                    existing.Date = metadata.Date;
-                    existing.Track = metadata.Track;
-
-                    if (existing.DateAdded == SystemTime.MinValueUtc)
-                    {
-                        existing.DateAdded = metadata.DateAdded;
-                    }
-
-                    existing.DateUpdated = metadata.DateUpdated;
-                    existing.MetadataKind = metadata.MetadataKind;
-                    existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-                    existing.OriginalTitle = metadata.OriginalTitle;
-
-                    bool updated = await UpdateMetadataCollections(
-                        existing,
-                        metadata,
-                        _songRepository.AddGenre,
-                        _songRepository.AddTag,
-                        (_, _) => Task.FromResult(false),
-                        (_, _) => Task.FromResult(false));
-
-                    return await _metadataRepository.Update(existing) || updated;
-                },
-                async () =>
-                {
-                    metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
-                        ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
-                        : metadata.SortTitle;
-                    metadata.SongId = song.Id;
-                    song.SongMetadata = new List<SongMetadata> { metadata };
-
-                    return await _metadataRepository.Add(metadata);
-                });
-
-        private async Task<Option<ShowMetadata>> LoadTelevisionShowMetadata(string nfoFileName)
-        {
-            try
-            {
-                await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
-                Option<TvShowNfo> maybeNfo = TvShowSerializer.Deserialize(fileStream) as TvShowNfo;
-                return maybeNfo.Match<Option<ShowMetadata>>(
-                    nfo =>
-                    {
-                        DateTime dateAdded = DateTime.UtcNow;
-                        DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
-
-                        return new ShowMetadata
-                        {
-                            MetadataKind = MetadataKind.Sidecar,
-                            DateAdded = dateAdded,
-                            DateUpdated = dateUpdated,
-                            Title = nfo.Title,
-                            Plot = nfo.Plot,
-                            Outline = nfo.Outline,
-                            Tagline = nfo.Tagline,
-                            ContentRating = nfo.ContentRating,
-                            Year = GetYear(nfo.Year, nfo.Premiered),
-                            ReleaseDate = GetAired(nfo.Year, nfo.Premiered),
-                            Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
-                            Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
-                            Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList(),
-                            Actors = Actors(nfo.Actors, dateAdded, dateUpdated),
-                            Guids = nfo.UniqueIds
-                                .Map(id => new MetadataGuid { Guid = $"{id.Type}://{id.Guid}" })
-                                .ToList()
-                        };
-                    },
-                    None);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogInformation(ex, "Failed to read TV show nfo metadata from {Path}", nfoFileName);
-                return None;
-            }
+                () => Task.FromResult(updated)) || updated;
         }
 
-        private async Task<Option<ArtistMetadata>> LoadArtistMetadata(string nfoFileName)
-        {
-            try
-            {
-                await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
-                Option<ArtistNfo> maybeNfo = ArtistSerializer.Deserialize(fileStream) as ArtistNfo;
-                return maybeNfo.Match<Option<ArtistMetadata>>(
-                    nfo => new ArtistMetadata
-                    {
-                        MetadataKind = MetadataKind.Sidecar,
-                        DateAdded = DateTime.UtcNow,
-                        DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
-                        Title = nfo.Name,
-                        Disambiguation = nfo.Disambiguation,
-                        Biography = nfo.Biography,
-                        Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
-                        Styles = nfo.Styles.Map(s => new Style { Name = s }).ToList(),
-                        Moods = nfo.Moods.Map(m => new Mood { Name = m }).ToList()
-                    },
-                    None);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogInformation(ex, "Failed to read artist nfo metadata from {Path}", nfoFileName);
-                return None;
-            }
-        }
+        return updated;
+    }
 
-        private async Task<List<EpisodeMetadata>> LoadEpisodeMetadata(Episode episode, string nfoFileName)
-        {
-            try
+    private Task<bool> ApplyMetadataUpdate(Movie movie, MovieMetadata metadata) =>
+        Optional(movie.MovieMetadata).Flatten().HeadOrNone().Match(
+            async existing =>
             {
-                await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
-                List<TvShowEpisodeNfo> nfos = await _episodeNfoReader.Read(fileStream);
-                var result = new List<EpisodeMetadata>();
-                foreach (TvShowEpisodeNfo nfo in nfos)
+                existing.ContentRating = metadata.ContentRating;
+                existing.Outline = metadata.Outline;
+                existing.Plot = metadata.Plot;
+                existing.Tagline = metadata.Tagline;
+                existing.Title = metadata.Title;
+
+                if (existing.DateAdded == SystemTime.MinValueUtc)
                 {
-                    DateTime dateAdded = DateTime.UtcNow;
-                    DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
-
-                    var metadata = new EpisodeMetadata
-                    {
-                        MetadataKind = MetadataKind.Sidecar,
-                        DateAdded = dateAdded,
-                        DateUpdated = dateUpdated,
-                        Title = nfo.Title,
-                        SortTitle = _fallbackMetadataProvider.GetSortTitle(nfo.Title),
-                        EpisodeNumber = nfo.Episode,
-                        Year = GetYear(0, nfo.Aired),
-                        ReleaseDate = GetAired(0, nfo.Aired),
-                        Plot = nfo.Plot,
-                        Actors = Actors(nfo.Actors, dateAdded, dateUpdated),
-                        Guids = nfo.UniqueIds
-                            .Map(id => new MetadataGuid { Guid = $"{id.Type}://{id.Guid}" })
-                            .ToList(),
-                        Directors = nfo.Directors.Map(d => new Director { Name = d }).ToList(),
-                        Writers = nfo.Writers.Map(w => new Writer { Name = w }).ToList(),
-                        Genres = new List<Genre>(),
-                        Tags = new List<Tag>(),
-                        Studios = new List<Studio>(),
-                        Artwork = new List<Artwork>()
-                    };
-
-                    result.Add(metadata);
+                    existing.DateAdded = metadata.DateAdded;
                 }
 
-                return result;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogInformation(ex, "Failed to read TV episode nfo metadata from {Path}", nfoFileName);
-                return _fallbackMetadataProvider.GetFallbackMetadata(episode);
-            }
-        }
+                existing.DateUpdated = metadata.DateUpdated;
+                existing.MetadataKind = metadata.MetadataKind;
+                existing.OriginalTitle = metadata.OriginalTitle;
+                existing.ReleaseDate = metadata.ReleaseDate;
+                existing.Year = metadata.Year;
+                existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
 
-        private async Task<Option<MovieMetadata>> LoadMovieMetadata(Movie movie, string nfoFileName)
-        {
-            try
-            {
-                await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
-                Option<MovieNfo> maybeNfo = MovieSerializer.Deserialize(fileStream) as MovieNfo;
-                return maybeNfo.Match<Option<MovieMetadata>>(
-                    nfo =>
+                bool updated = await UpdateMetadataCollections(
+                    existing,
+                    metadata,
+                    _movieRepository.AddGenre,
+                    _movieRepository.AddTag,
+                    _movieRepository.AddStudio,
+                    _movieRepository.AddActor);
+
+                foreach (Director director in existing.Directors
+                             .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name)).ToList())
+                {
+                    existing.Directors.Remove(director);
+                    if (await _metadataRepository.RemoveDirector(director))
                     {
-                        DateTime dateAdded = DateTime.UtcNow;
-                        DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
+                        updated = true;
+                    }
+                }
 
-                        return new MovieMetadata
-                        {
-                            MetadataKind = MetadataKind.Sidecar,
-                            DateAdded = dateAdded,
-                            DateUpdated = dateUpdated,
-                            Title = nfo.Title,
-                            Year = nfo.Year,
-                            ContentRating = nfo.ContentRating,
-                            ReleaseDate = nfo.Premiered,
-                            Plot = nfo.Plot,
-                            Outline = nfo.Outline,
-                            Tagline = nfo.Tagline,
-                            Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
-                            Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
-                            Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList(),
-                            Actors = Actors(nfo.Actors, dateAdded, dateUpdated),
-                            Directors = nfo.Directors.Map(d => new Director { Name = d }).ToList(),
-                            Writers = nfo.Writers.Map(w => new Writer { Name = w }).ToList(),
-                            Guids = nfo.UniqueIds
-                                .Map(id => new MetadataGuid { Guid = $"{id.Type}://{id.Guid}" })
-                                .ToList()
-                        };
-                    },
-                    None);
-            }
-            catch (Exception ex)
+                foreach (Director director in metadata.Directors
+                             .Filter(d => existing.Directors.All(d2 => d2.Name != d.Name)).ToList())
+                {
+                    existing.Directors.Add(director);
+                    if (await _movieRepository.AddDirector(existing, director))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (Writer writer in existing.Writers
+                             .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name)).ToList())
+                {
+                    existing.Writers.Remove(writer);
+                    if (await _metadataRepository.RemoveWriter(writer))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (Writer writer in metadata.Writers
+                             .Filter(w => existing.Writers.All(w2 => w2.Name != w.Name)).ToList())
+                {
+                    existing.Writers.Add(writer);
+                    if (await _movieRepository.AddWriter(existing, writer))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (MetadataGuid guid in existing.Guids
+                             .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
+                {
+                    existing.Guids.Remove(guid);
+                    if (await _metadataRepository.RemoveGuid(guid))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (MetadataGuid guid in metadata.Guids
+                             .Filter(g => existing.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
+                {
+                    existing.Guids.Add(guid);
+                    if (await _metadataRepository.AddGuid(existing, guid))
+                    {
+                        updated = true;
+                    }
+                }
+
+                return await _metadataRepository.Update(existing) || updated;
+            },
+            async () =>
             {
-                _logger.LogInformation(ex, "Failed to read Movie nfo metadata from {Path}", nfoFileName);
-                return _fallbackMetadataProvider.GetFallbackMetadata(movie);
-            }
-        }
+                metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+                metadata.MovieId = movie.Id;
+                movie.MovieMetadata = new List<MovieMetadata> { metadata };
 
-        private static int? GetYear(int? year, string premiered)
-        {
-            if (year is > 1000)
+                return await _metadataRepository.Add(metadata);
+            });
+
+    private Task<bool> ApplyMetadataUpdate(Show show, ShowMetadata metadata) =>
+        Optional(show.ShowMetadata).Flatten().HeadOrNone().Match(
+            async existing =>
             {
-                return year;
-            }
+                existing.ContentRating = metadata.ContentRating;
+                existing.Outline = metadata.Outline;
+                existing.Plot = metadata.Plot;
+                existing.Tagline = metadata.Tagline;
+                existing.Title = metadata.Title;
 
-            if (string.IsNullOrWhiteSpace(premiered))
+                if (existing.DateAdded == SystemTime.MinValueUtc)
+                {
+                    existing.DateAdded = metadata.DateAdded;
+                }
+
+                existing.DateUpdated = metadata.DateUpdated;
+                existing.MetadataKind = metadata.MetadataKind;
+                existing.OriginalTitle = metadata.OriginalTitle;
+                existing.ReleaseDate = metadata.ReleaseDate;
+                existing.Year = metadata.Year;
+                existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+
+                bool updated = await UpdateMetadataCollections(
+                    existing,
+                    metadata,
+                    _televisionRepository.AddGenre,
+                    _televisionRepository.AddTag,
+                    _televisionRepository.AddStudio,
+                    _televisionRepository.AddActor);
+
+                foreach (MetadataGuid guid in existing.Guids
+                             .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
+                {
+                    existing.Guids.Remove(guid);
+                    if (await _metadataRepository.RemoveGuid(guid))
+                    {
+                        updated = true;
+                    }
+                }
+
+                foreach (MetadataGuid guid in metadata.Guids
+                             .Filter(g => existing.Guids.All(g2 => g2.Guid != g.Guid)).ToList())
+                {
+                    existing.Guids.Add(guid);
+                    if (await _metadataRepository.AddGuid(existing, guid))
+                    {
+                        updated = true;
+                    }
+                }
+
+                return await _metadataRepository.Update(existing) || updated;
+            },
+            async () =>
             {
-                return null;
-            }
+                metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+                metadata.ShowId = show.Id;
+                show.ShowMetadata = new List<ShowMetadata> { metadata };
 
-            if (DateTime.TryParse(premiered, out DateTime parsed))
+                return await _metadataRepository.Add(metadata);
+            });
+
+    private Task<bool> ApplyMetadataUpdate(Artist artist, ArtistMetadata metadata) =>
+        Optional(artist.ArtistMetadata).Flatten().HeadOrNone().Match(
+            async existing =>
             {
-                return parsed.Year;
-            }
+                existing.Title = metadata.Title;
+                existing.Disambiguation = metadata.Disambiguation;
+                existing.Biography = metadata.Biography;
 
-            return null;
-        }
+                if (existing.DateAdded == SystemTime.MinValueUtc)
+                {
+                    existing.DateAdded = metadata.DateAdded;
+                }
 
-        private static DateTime? GetAired(int? year, string aired)
-        {
-            DateTime? fallback = year is > 1000 ? new DateTime(year.Value, 1, 1) : null;
+                existing.DateUpdated = metadata.DateUpdated;
+                existing.MetadataKind = metadata.MetadataKind;
+                existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
 
-            if (string.IsNullOrWhiteSpace(aired))
-            {
-                return fallback;
-            }
+                var updated = false;
 
-            return DateTime.TryParse(aired, out DateTime parsed) ? parsed : fallback;
-        }
-
-        private async Task<bool> UpdateMetadataCollections<T>(
-            T existing,
-            T incoming,
-            Func<T, Genre, Task<bool>> addGenre,
-            Func<T, Tag, Task<bool>> addTag,
-            Func<T, Studio, Task<bool>> addStudio,
-            Func<T, Actor, Task<bool>> addActor)
-            where T : Domain.Metadata
-        {
-            var updated = false;
-
-            if (existing is not EpisodeMetadata)
-            {
-                foreach (Genre genre in existing.Genres.Filter(g => incoming.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
+                foreach (Genre genre in existing.Genres.Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
+                             .ToList())
                 {
                     existing.Genres.Remove(genre);
                     if (await _metadataRepository.RemoveGenre(genre))
@@ -1024,129 +613,532 @@ namespace ErsatzTV.Core.Metadata
                     }
                 }
 
-                foreach (Genre genre in incoming.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
+                foreach (Genre genre in metadata.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
+                             .ToList())
                 {
                     existing.Genres.Add(genre);
-                    if (await addGenre(existing, genre))
+                    if (await _artistRepository.AddGenre(existing, genre))
                     {
                         updated = true;
                     }
                 }
 
-                foreach (Tag tag in existing.Tags.Filter(t => incoming.Tags.All(t2 => t2.Name != t.Name))
-                    .ToList())
+                foreach (Style style in existing.Styles.Filter(s => metadata.Styles.All(s2 => s2.Name != s.Name))
+                             .ToList())
                 {
-                    existing.Tags.Remove(tag);
-                    if (await _metadataRepository.RemoveTag(tag))
+                    existing.Styles.Remove(style);
+                    if (await _metadataRepository.RemoveStyle(style))
                     {
                         updated = true;
                     }
                 }
 
-                foreach (Tag tag in incoming.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
-                    .ToList())
+                foreach (Style style in metadata.Styles.Filter(s => existing.Styles.All(s2 => s2.Name != s.Name))
+                             .ToList())
                 {
-                    existing.Tags.Add(tag);
-                    if (await addTag(existing, tag))
+                    existing.Styles.Add(style);
+                    if (await _artistRepository.AddStyle(existing, style))
                     {
                         updated = true;
                     }
                 }
 
-                foreach (Studio studio in existing.Studios
-                    .Filter(s => incoming.Studios.All(s2 => s2.Name != s.Name))
-                    .ToList())
+                foreach (Mood mood in existing.Moods.Filter(m => metadata.Moods.All(m2 => m2.Name != m.Name))
+                             .ToList())
                 {
-                    existing.Studios.Remove(studio);
-                    if (await _metadataRepository.RemoveStudio(studio))
+                    existing.Moods.Remove(mood);
+                    if (await _metadataRepository.RemoveMood(mood))
                     {
                         updated = true;
                     }
                 }
 
-                foreach (Studio studio in incoming.Studios
-                    .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
-                    .ToList())
+                foreach (Mood mood in metadata.Moods.Filter(s => existing.Moods.All(m2 => m2.Name != s.Name))
+                             .ToList())
                 {
-                    existing.Studios.Add(studio);
-                    if (await addStudio(existing, studio))
+                    existing.Moods.Add(mood);
+                    if (await _artistRepository.AddMood(existing, mood))
                     {
                         updated = true;
                     }
                 }
-            }
 
-            if (existing is not MusicVideoMetadata and not SongMetadata)
+                return await _metadataRepository.Update(existing) || updated;
+            },
+            async () =>
             {
-                foreach (Actor actor in existing.Actors
-                    .Filter(a => incoming.Actors.All(a2 => a2.Name != a.Name))
-                    .ToList())
+                metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+                metadata.ArtistId = artist.Id;
+                artist.ArtistMetadata = new List<ArtistMetadata> { metadata };
+
+                return await _metadataRepository.Add(metadata);
+            });
+
+    private Task<bool> ApplyMetadataUpdate(MusicVideo musicVideo, MusicVideoMetadata metadata) =>
+        Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone().Match(
+            async existing =>
+            {
+                existing.Title = metadata.Title;
+                existing.Year = metadata.Year;
+                existing.Plot = metadata.Plot;
+                existing.Album = metadata.Album;
+
+                if (existing.DateAdded == SystemTime.MinValueUtc)
                 {
-                    existing.Actors.Remove(actor);
-                    if (await _metadataRepository.RemoveActor(actor))
-                    {
-                        updated = true;
-                    }
+                    existing.DateAdded = metadata.DateAdded;
                 }
 
-                foreach (Actor actor in incoming.Actors
-                    .Filter(a => existing.Actors.All(a2 => a2.Name != a.Name))
-                    .ToList())
+                existing.DateUpdated = metadata.DateUpdated;
+                existing.MetadataKind = metadata.MetadataKind;
+                existing.OriginalTitle = metadata.OriginalTitle;
+                existing.ReleaseDate = metadata.ReleaseDate;
+                existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+
+                bool updated = await UpdateMetadataCollections(
+                    existing,
+                    metadata,
+                    _musicVideoRepository.AddGenre,
+                    _musicVideoRepository.AddTag,
+                    _musicVideoRepository.AddStudio,
+                    (_, _) => Task.FromResult(false));
+
+                return await _metadataRepository.Update(existing) || updated;
+            },
+            async () =>
+            {
+                metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+                metadata.MusicVideoId = musicVideo.Id;
+                musicVideo.MusicVideoMetadata = new List<MusicVideoMetadata> { metadata };
+
+                return await _metadataRepository.Add(metadata);
+            });
+        
+    private Task<bool> ApplyMetadataUpdate(OtherVideo otherVideo, OtherVideoMetadata metadata) =>
+        Optional(otherVideo.OtherVideoMetadata).Flatten().HeadOrNone().Match(
+            async existing =>
+            {
+                existing.Title = metadata.Title;
+
+                if (existing.DateAdded == SystemTime.MinValueUtc)
                 {
-                    existing.Actors.Add(actor);
-                    if (await addActor(existing, actor))
-                    {
-                        updated = true;
-                    }
+                    existing.DateAdded = metadata.DateAdded;
                 }
-            }
 
-            return updated;
-        }
+                existing.DateUpdated = metadata.DateUpdated;
+                existing.MetadataKind = metadata.MetadataKind;
+                existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+                existing.OriginalTitle = metadata.OriginalTitle;
 
-        private static List<Actor> Actors(List<ActorNfo> actorNfos, DateTime dateAdded, DateTime dateUpdated)
+                bool updated = await UpdateMetadataCollections(
+                    existing,
+                    metadata,
+                    (_, _) => Task.FromResult(false),
+                    _otherVideoRepository.AddTag,
+                    (_, _) => Task.FromResult(false),
+                    (_, _) => Task.FromResult(false));
+
+                return await _metadataRepository.Update(existing) || updated;
+            },
+            async () =>
+            {
+                metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+                metadata.OtherVideoId = otherVideo.Id;
+                otherVideo.OtherVideoMetadata = new List<OtherVideoMetadata> { metadata };
+
+                return await _metadataRepository.Add(metadata);
+            });
+        
+    private Task<bool> ApplyMetadataUpdate(Song song, SongMetadata metadata) =>
+        Optional(song.SongMetadata).Flatten().HeadOrNone().Match(
+            async existing =>
+            {
+                existing.Title = metadata.Title;
+                existing.Artist = metadata.Artist;
+                existing.Album = metadata.Album;
+                existing.Date = metadata.Date;
+                existing.Track = metadata.Track;
+
+                if (existing.DateAdded == SystemTime.MinValueUtc)
+                {
+                    existing.DateAdded = metadata.DateAdded;
+                }
+
+                existing.DateUpdated = metadata.DateUpdated;
+                existing.MetadataKind = metadata.MetadataKind;
+                existing.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+                existing.OriginalTitle = metadata.OriginalTitle;
+
+                bool updated = await UpdateMetadataCollections(
+                    existing,
+                    metadata,
+                    _songRepository.AddGenre,
+                    _songRepository.AddTag,
+                    (_, _) => Task.FromResult(false),
+                    (_, _) => Task.FromResult(false));
+
+                return await _metadataRepository.Update(existing) || updated;
+            },
+            async () =>
+            {
+                metadata.SortTitle = string.IsNullOrWhiteSpace(metadata.SortTitle)
+                    ? _fallbackMetadataProvider.GetSortTitle(metadata.Title)
+                    : metadata.SortTitle;
+                metadata.SongId = song.Id;
+                song.SongMetadata = new List<SongMetadata> { metadata };
+
+                return await _metadataRepository.Add(metadata);
+            });
+
+    private async Task<Option<ShowMetadata>> LoadTelevisionShowMetadata(string nfoFileName)
+    {
+        try
         {
-            var result = new List<Actor>();
-
-            for (var i = 0; i < actorNfos.Count; i++)
-            {
-                ActorNfo actorNfo = actorNfos[i];
-
-                var actor = new Actor
+            await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
+            Option<TvShowNfo> maybeNfo = TvShowSerializer.Deserialize(fileStream) as TvShowNfo;
+            return maybeNfo.Match<Option<ShowMetadata>>(
+                nfo =>
                 {
-                    Name = actorNfo.Name,
-                    Role = actorNfo.Role,
-                    Order = actorNfo.Order ?? i
+                    DateTime dateAdded = DateTime.UtcNow;
+                    DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
+
+                    return new ShowMetadata
+                    {
+                        MetadataKind = MetadataKind.Sidecar,
+                        DateAdded = dateAdded,
+                        DateUpdated = dateUpdated,
+                        Title = nfo.Title,
+                        Plot = nfo.Plot,
+                        Outline = nfo.Outline,
+                        Tagline = nfo.Tagline,
+                        ContentRating = nfo.ContentRating,
+                        Year = GetYear(nfo.Year, nfo.Premiered),
+                        ReleaseDate = GetAired(nfo.Year, nfo.Premiered),
+                        Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
+                        Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
+                        Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList(),
+                        Actors = Actors(nfo.Actors, dateAdded, dateUpdated),
+                        Guids = nfo.UniqueIds
+                            .Map(id => new MetadataGuid { Guid = $"{id.Type}://{id.Guid}" })
+                            .ToList()
+                    };
+                },
+                None);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogInformation(ex, "Failed to read TV show nfo metadata from {Path}", nfoFileName);
+            return None;
+        }
+    }
+
+    private async Task<Option<ArtistMetadata>> LoadArtistMetadata(string nfoFileName)
+    {
+        try
+        {
+            await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
+            Option<ArtistNfo> maybeNfo = ArtistSerializer.Deserialize(fileStream) as ArtistNfo;
+            return maybeNfo.Match<Option<ArtistMetadata>>(
+                nfo => new ArtistMetadata
+                {
+                    MetadataKind = MetadataKind.Sidecar,
+                    DateAdded = DateTime.UtcNow,
+                    DateUpdated = File.GetLastWriteTimeUtc(nfoFileName),
+                    Title = nfo.Name,
+                    Disambiguation = nfo.Disambiguation,
+                    Biography = nfo.Biography,
+                    Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
+                    Styles = nfo.Styles.Map(s => new Style { Name = s }).ToList(),
+                    Moods = nfo.Moods.Map(m => new Mood { Name = m }).ToList()
+                },
+                None);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogInformation(ex, "Failed to read artist nfo metadata from {Path}", nfoFileName);
+            return None;
+        }
+    }
+
+    private async Task<List<EpisodeMetadata>> LoadEpisodeMetadata(Episode episode, string nfoFileName)
+    {
+        try
+        {
+            await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
+            List<TvShowEpisodeNfo> nfos = await _episodeNfoReader.Read(fileStream);
+            var result = new List<EpisodeMetadata>();
+            foreach (TvShowEpisodeNfo nfo in nfos)
+            {
+                DateTime dateAdded = DateTime.UtcNow;
+                DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
+
+                var metadata = new EpisodeMetadata
+                {
+                    MetadataKind = MetadataKind.Sidecar,
+                    DateAdded = dateAdded,
+                    DateUpdated = dateUpdated,
+                    Title = nfo.Title,
+                    SortTitle = _fallbackMetadataProvider.GetSortTitle(nfo.Title),
+                    EpisodeNumber = nfo.Episode,
+                    Year = GetYear(0, nfo.Aired),
+                    ReleaseDate = GetAired(0, nfo.Aired),
+                    Plot = nfo.Plot,
+                    Actors = Actors(nfo.Actors, dateAdded, dateUpdated),
+                    Guids = nfo.UniqueIds
+                        .Map(id => new MetadataGuid { Guid = $"{id.Type}://{id.Guid}" })
+                        .ToList(),
+                    Directors = nfo.Directors.Map(d => new Director { Name = d }).ToList(),
+                    Writers = nfo.Writers.Map(w => new Writer { Name = w }).ToList(),
+                    Genres = new List<Genre>(),
+                    Tags = new List<Tag>(),
+                    Studios = new List<Studio>(),
+                    Artwork = new List<Artwork>()
                 };
 
-                if (!string.IsNullOrWhiteSpace(actorNfo.Thumb))
-                {
-                    actor.Artwork = new Artwork
-                    {
-                        Path = actorNfo.Thumb,
-                        ArtworkKind = ArtworkKind.Thumbnail,
-                        DateAdded = dateAdded,
-                        DateUpdated = dateUpdated
-                    };
-                }
-
-                result.Add(actor);
+                result.Add(metadata);
             }
 
             return result;
         }
-        
-        private static IEnumerable<string> SplitGenres(string genre)
+        catch (Exception ex)
         {
-            char[] delimiters = new[] { '/', '|', ';', '\\' }
-                .Filter(d => genre.IndexOf(d, StringComparison.OrdinalIgnoreCase) != -1)
-                .DefaultIfEmpty(',')
-                .ToArray();
-            
-            return genre.Split(delimiters, StringSplitOptions.RemoveEmptyEntries)
-                .Where(i => !string.IsNullOrWhiteSpace(i))
-                .Select(i => i.Trim());
+            _logger.LogInformation(ex, "Failed to read TV episode nfo metadata from {Path}", nfoFileName);
+            return _fallbackMetadataProvider.GetFallbackMetadata(episode);
         }
     }
-}
+
+    private async Task<Option<MovieMetadata>> LoadMovieMetadata(Movie movie, string nfoFileName)
+    {
+        try
+        {
+            await using FileStream fileStream = File.Open(nfoFileName, FileMode.Open, FileAccess.Read);
+            Option<MovieNfo> maybeNfo = MovieSerializer.Deserialize(fileStream) as MovieNfo;
+            return maybeNfo.Match<Option<MovieMetadata>>(
+                nfo =>
+                {
+                    DateTime dateAdded = DateTime.UtcNow;
+                    DateTime dateUpdated = File.GetLastWriteTimeUtc(nfoFileName);
+
+                    return new MovieMetadata
+                    {
+                        MetadataKind = MetadataKind.Sidecar,
+                        DateAdded = dateAdded,
+                        DateUpdated = dateUpdated,
+                        Title = nfo.Title,
+                        Year = nfo.Year,
+                        ContentRating = nfo.ContentRating,
+                        ReleaseDate = nfo.Premiered,
+                        Plot = nfo.Plot,
+                        Outline = nfo.Outline,
+                        Tagline = nfo.Tagline,
+                        Genres = nfo.Genres.Map(g => new Genre { Name = g }).ToList(),
+                        Tags = nfo.Tags.Map(t => new Tag { Name = t }).ToList(),
+                        Studios = nfo.Studios.Map(s => new Studio { Name = s }).ToList(),
+                        Actors = Actors(nfo.Actors, dateAdded, dateUpdated),
+                        Directors = nfo.Directors.Map(d => new Director { Name = d }).ToList(),
+                        Writers = nfo.Writers.Map(w => new Writer { Name = w }).ToList(),
+                        Guids = nfo.UniqueIds
+                            .Map(id => new MetadataGuid { Guid = $"{id.Type}://{id.Guid}" })
+                            .ToList()
+                    };
+                },
+                None);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogInformation(ex, "Failed to read Movie nfo metadata from {Path}", nfoFileName);
+            return _fallbackMetadataProvider.GetFallbackMetadata(movie);
+        }
+    }
+
+    private static int? GetYear(int? year, string premiered)
+    {
+        if (year is > 1000)
+        {
+            return year;
+        }
+
+        if (string.IsNullOrWhiteSpace(premiered))
+        {
+            return null;
+        }
+
+        if (DateTime.TryParse(premiered, out DateTime parsed))
+        {
+            return parsed.Year;
+        }
+
+        return null;
+    }
+
+    private static DateTime? GetAired(int? year, string aired)
+    {
+        DateTime? fallback = year is > 1000 ? new DateTime(year.Value, 1, 1) : null;
+
+        if (string.IsNullOrWhiteSpace(aired))
+        {
+            return fallback;
+        }
+
+        return DateTime.TryParse(aired, out DateTime parsed) ? parsed : fallback;
+    }
+
+    private async Task<bool> UpdateMetadataCollections<T>(
+        T existing,
+        T incoming,
+        Func<T, Genre, Task<bool>> addGenre,
+        Func<T, Tag, Task<bool>> addTag,
+        Func<T, Studio, Task<bool>> addStudio,
+        Func<T, Actor, Task<bool>> addActor)
+        where T : Domain.Metadata
+    {
+        var updated = false;
+
+        if (existing is not EpisodeMetadata)
+        {
+            foreach (Genre genre in existing.Genres.Filter(g => incoming.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                existing.Genres.Remove(genre);
+                if (await _metadataRepository.RemoveGenre(genre))
+                {
+                    updated = true;
+                }
+            }
+
+            foreach (Genre genre in incoming.Genres.Filter(g => existing.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                existing.Genres.Add(genre);
+                if (await addGenre(existing, genre))
+                {
+                    updated = true;
+                }
+            }
+
+            foreach (Tag tag in existing.Tags.Filter(t => incoming.Tags.All(t2 => t2.Name != t.Name))
+                         .ToList())
+            {
+                existing.Tags.Remove(tag);
+                if (await _metadataRepository.RemoveTag(tag))
+                {
+                    updated = true;
+                }
+            }
+
+            foreach (Tag tag in incoming.Tags.Filter(t => existing.Tags.All(t2 => t2.Name != t.Name))
+                         .ToList())
+            {
+                existing.Tags.Add(tag);
+                if (await addTag(existing, tag))
+                {
+                    updated = true;
+                }
+            }
+
+            foreach (Studio studio in existing.Studios
+                         .Filter(s => incoming.Studios.All(s2 => s2.Name != s.Name))
+                         .ToList())
+            {
+                existing.Studios.Remove(studio);
+                if (await _metadataRepository.RemoveStudio(studio))
+                {
+                    updated = true;
+                }
+            }
+
+            foreach (Studio studio in incoming.Studios
+                         .Filter(s => existing.Studios.All(s2 => s2.Name != s.Name))
+                         .ToList())
+            {
+                existing.Studios.Add(studio);
+                if (await addStudio(existing, studio))
+                {
+                    updated = true;
+                }
+            }
+        }
+
+        if (existing is not MusicVideoMetadata and not SongMetadata)
+        {
+            foreach (Actor actor in existing.Actors
+                         .Filter(a => incoming.Actors.All(a2 => a2.Name != a.Name))
+                         .ToList())
+            {
+                existing.Actors.Remove(actor);
+                if (await _metadataRepository.RemoveActor(actor))
+                {
+                    updated = true;
+                }
+            }
+
+            foreach (Actor actor in incoming.Actors
+                         .Filter(a => existing.Actors.All(a2 => a2.Name != a.Name))
+                         .ToList())
+            {
+                existing.Actors.Add(actor);
+                if (await addActor(existing, actor))
+                {
+                    updated = true;
+                }
+            }
+        }
+
+        return updated;
+    }
+
+    private static List<Actor> Actors(List<ActorNfo> actorNfos, DateTime dateAdded, DateTime dateUpdated)
+    {
+        var result = new List<Actor>();
+
+        for (var i = 0; i < actorNfos.Count; i++)
+        {
+            ActorNfo actorNfo = actorNfos[i];
+
+            var actor = new Actor
+            {
+                Name = actorNfo.Name,
+                Role = actorNfo.Role,
+                Order = actorNfo.Order ?? i
+            };
+
+            if (!string.IsNullOrWhiteSpace(actorNfo.Thumb))
+            {
+                actor.Artwork = new Artwork
+                {
+                    Path = actorNfo.Thumb,
+                    ArtworkKind = ArtworkKind.Thumbnail,
+                    DateAdded = dateAdded,
+                    DateUpdated = dateUpdated
+                };
+            }
+
+            result.Add(actor);
+        }
+
+        return result;
+    }
+        
+    private static IEnumerable<string> SplitGenres(string genre)
+    {
+        char[] delimiters = new[] { '/', '|', ';', '\\' }
+            .Filter(d => genre.IndexOf(d, StringComparison.OrdinalIgnoreCase) != -1)
+            .DefaultIfEmpty(',')
+            .ToArray();
+            
+        return genre.Split(delimiters, StringSplitOptions.RemoveEmptyEntries)
+            .Where(i => !string.IsNullOrWhiteSpace(i))
+            .Select(i => i.Trim());
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs b/ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs
index 11d9dfa61..9ca3e0f55 100644
--- a/ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs
+++ b/ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs
@@ -1,397 +1,390 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
+using System.Diagnostics;
 using System.Globalization;
-using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class LocalStatisticsProvider : ILocalStatisticsProvider
 {
-    public class LocalStatisticsProvider : ILocalStatisticsProvider
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILogger<LocalStatisticsProvider> _logger;
+    private readonly IMetadataRepository _metadataRepository;
+
+    public LocalStatisticsProvider(
+        IMetadataRepository metadataRepository,
+        ILocalFileSystem localFileSystem,
+        ILogger<LocalStatisticsProvider> logger)
     {
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILogger<LocalStatisticsProvider> _logger;
-        private readonly IMetadataRepository _metadataRepository;
+        _metadataRepository = metadataRepository;
+        _localFileSystem = localFileSystem;
+        _logger = logger;
+    }
 
-        public LocalStatisticsProvider(
-            IMetadataRepository metadataRepository,
-            ILocalFileSystem localFileSystem,
-            ILogger<LocalStatisticsProvider> logger)
+    public async Task<Either<BaseError, bool>> RefreshStatistics(string ffprobePath, MediaItem mediaItem)
+    {
+        try
         {
-            _metadataRepository = metadataRepository;
-            _localFileSystem = localFileSystem;
-            _logger = logger;
+            string filePath = mediaItem.GetHeadVersion().MediaFiles.Head().Path;
+            return await RefreshStatistics(ffprobePath, mediaItem, filePath);
         }
-
-        public async Task<Either<BaseError, bool>> RefreshStatistics(string ffprobePath, MediaItem mediaItem)
+        catch (Exception ex)
         {
-            try
-            {
-                string filePath = mediaItem.GetHeadVersion().MediaFiles.Head().Path;
-                return await RefreshStatistics(ffprobePath, mediaItem, filePath);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to refresh statistics for media item {Id}", mediaItem.Id);
-                return BaseError.New(ex.Message);
-            }
+            _logger.LogWarning(ex, "Failed to refresh statistics for media item {Id}", mediaItem.Id);
+            return BaseError.New(ex.Message);
         }
+    }
 
-        public async Task<Either<BaseError, bool>> RefreshStatistics(
-            string ffprobePath,
-            MediaItem mediaItem,
-            string mediaItemPath)
+    public async Task<Either<BaseError, bool>> RefreshStatistics(
+        string ffprobePath,
+        MediaItem mediaItem,
+        string mediaItemPath)
+    {
+        try
         {
-            try
-            {
-                Either<BaseError, FFprobe> maybeProbe = await GetProbeOutput(ffprobePath, mediaItemPath);
-                return await maybeProbe.Match(
-                    async ffprobe =>
-                    {
-                        MediaVersion version = ProjectToMediaVersion(mediaItemPath, ffprobe);
-                        bool result = await ApplyVersionUpdate(mediaItem, version, mediaItemPath);
-                        return Right<BaseError, bool>(result);
-                    },
-                    error => Task.FromResult(Left<BaseError, bool>(error)));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to refresh statistics for media item {Id}", mediaItem.Id);
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        public async Task<Either<BaseError, Dictionary<string, string>>> GetFormatTags(
-            string ffprobePath,
-            MediaItem mediaItem)
-        {
-            try
-            {
-                string mediaItemPath = mediaItem.GetHeadVersion().MediaFiles.Head().Path;
-                Either<BaseError, FFprobe> maybeProbe = await GetProbeOutput(ffprobePath, mediaItemPath);
-                return maybeProbe.Match(
-                    ffprobe =>
-                    {
-                        var result = new Dictionary<string, string>();
-                        
-                        if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.album))
-                        {
-                            result.Add(MetadataFormatTag.Album, ffprobe.format.tags.album);
-                        }
-
-                        if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.artist))
-                        {
-                            result.Add(MetadataFormatTag.Artist, ffprobe.format.tags.artist);
-                        }
-
-                        if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.date))
-                        {
-                            result.Add(MetadataFormatTag.Date, ffprobe.format.tags.date);
-                        }
-
-                        if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.genre))
-                        {
-                            result.Add(MetadataFormatTag.Genre, ffprobe.format.tags.genre);
-                        }
-
-                        if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.title))
-                        {
-                            result.Add(MetadataFormatTag.Title, ffprobe.format.tags.title);
-                        }
-
-                        if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.track))
-                        {
-                            result.Add(MetadataFormatTag.Track, ffprobe.format.tags.track);
-                        }
-
-                        return Right<BaseError, Dictionary<string, string>>(result);
-                    },
-                    Left<BaseError, Dictionary<string, string>>);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Failed to get format tags for media item {Id}", mediaItem.Id);
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        private async Task<bool> ApplyVersionUpdate(MediaItem mediaItem, MediaVersion version, string filePath)
-        {
-            MediaVersion mediaItemVersion = mediaItem.GetHeadVersion();
-
-            bool durationChange = mediaItemVersion.Duration != version.Duration;
-
-            version.DateUpdated = _localFileSystem.GetLastWriteTime(filePath);
-
-            return await _metadataRepository.UpdateLocalStatistics(mediaItem, version) && durationChange;
-        }
-
-        private Task<Either<BaseError, FFprobe>> GetProbeOutput(string ffprobePath, string filePath)
-        {
-            var startInfo = new ProcessStartInfo
-            {
-                FileName = ffprobePath,
-                RedirectStandardOutput = true,
-                RedirectStandardError = true,
-                UseShellExecute = false,
-                StandardOutputEncoding = Encoding.UTF8,
-                StandardErrorEncoding = Encoding.UTF8
-            };
-
-            startInfo.ArgumentList.Add("-v");
-            startInfo.ArgumentList.Add("quiet");
-            startInfo.ArgumentList.Add("-print_format");
-            startInfo.ArgumentList.Add("json");
-            startInfo.ArgumentList.Add("-show_format");
-            startInfo.ArgumentList.Add("-show_streams");
-            startInfo.ArgumentList.Add("-show_chapters");
-            startInfo.ArgumentList.Add("-i");
-            startInfo.ArgumentList.Add(filePath);
-
-            var probe = new Process
-            {
-                StartInfo = startInfo
-            };
-
-            probe.Start();
-            return probe.StandardOutput.ReadToEndAsync().MapAsync<string, Either<BaseError, FFprobe>>(
-                async output =>
+            Either<BaseError, FFprobe> maybeProbe = await GetProbeOutput(ffprobePath, mediaItemPath);
+            return await maybeProbe.Match(
+                async ffprobe =>
                 {
-                    await probe.WaitForExitAsync();
-                    return probe.ExitCode == 0
-                        ? JsonConvert.DeserializeObject<FFprobe>(output)
-                        : BaseError.New($"FFprobe at {ffprobePath} exited with code {probe.ExitCode}");
-                });
+                    MediaVersion version = ProjectToMediaVersion(mediaItemPath, ffprobe);
+                    bool result = await ApplyVersionUpdate(mediaItem, version, mediaItemPath);
+                    return Right<BaseError, bool>(result);
+                },
+                error => Task.FromResult(Left<BaseError, bool>(error)));
         }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to refresh statistics for media item {Id}", mediaItem.Id);
+            return BaseError.New(ex.Message);
+        }
+    }
 
-        internal MediaVersion ProjectToMediaVersion(string path, FFprobe probeOutput) =>
-            Optional(probeOutput)
-                .Filter(json => json?.format != null && json.streams != null)
-                .ToValidation<BaseError>("Unable to parse ffprobe output")
-                .ToEither<FFprobe>()
-                .Match(
-                    json =>
-                    {
-                        var version = new MediaVersion
-                        {
-                            Name = "Main",
-                            DateAdded = DateTime.UtcNow,
-                            Streams = new List<MediaStream>(),
-                            Chapters = new List<MediaChapter>()
-                        };
-
-                        if (double.TryParse(
-                            json.format.duration,
-                            NumberStyles.Number,
-                            CultureInfo.InvariantCulture,
-                            out double duration))
-                        {
-                            var seconds = TimeSpan.FromSeconds(duration);
-                            version.Duration = seconds;
-                        }
-                        else
-                        {
-                            _logger.LogWarning(
-                                "Media item at {Path} has a missing or invalid duration {Duration} and will cause scheduling issues",
-                                path,
-                                json.format.duration);
-                        }
-
-                        foreach (FFprobeStream audioStream in json.streams.Filter(s => s.codec_type == "audio"))
-                        {
-                            var stream = new MediaStream
-                            {
-                                MediaVersionId = version.Id,
-                                MediaStreamKind = MediaStreamKind.Audio,
-                                Index = audioStream.index,
-                                Codec = audioStream.codec_name,
-                                Profile = (audioStream.profile ?? string.Empty).ToLowerInvariant(),
-                                Channels = audioStream.channels
-                            };
-
-                            if (audioStream.disposition is not null)
-                            {
-                                stream.Default = audioStream.disposition.@default == 1;
-                                stream.Forced = audioStream.disposition.forced == 1;
-                            }
-
-                            if (audioStream.tags is not null)
-                            {
-                                stream.Language = audioStream.tags.language;
-                                stream.Title = audioStream.tags.title;
-                            }
-
-                            version.Streams.Add(stream);
-                        }
-
-                        FFprobeStream videoStream = json.streams.FirstOrDefault(s => s.codec_type == "video");
-                        if (videoStream != null)
-                        {
-                            version.SampleAspectRatio = string.IsNullOrWhiteSpace(videoStream.sample_aspect_ratio)
-                                ? "1:1"
-                                : videoStream.sample_aspect_ratio;
-                            version.DisplayAspectRatio = videoStream.display_aspect_ratio;
-                            version.Width = videoStream.width;
-                            version.Height = videoStream.height;
-                            version.VideoScanKind = ScanKindFromFieldOrder(videoStream.field_order);
-                            version.RFrameRate = videoStream.r_frame_rate;
-
-                            var stream = new MediaStream
-                            {
-                                MediaVersionId = version.Id,
-                                MediaStreamKind = MediaStreamKind.Video,
-                                Index = videoStream.index,
-                                Codec = videoStream.codec_name,
-                                Profile = (videoStream.profile ?? string.Empty).ToLowerInvariant(),
-                                PixelFormat = (videoStream.pix_fmt ?? string.Empty).ToLowerInvariant(),
-                            };
-
-                            if (int.TryParse(videoStream.bits_per_raw_sample, out int bitsPerRawSample))
-                            {
-                                stream.BitsPerRawSample = bitsPerRawSample;
-                            }
-
-                            if (videoStream.disposition is not null)
-                            {
-                                stream.Default = videoStream.disposition.@default == 1;
-                                stream.Forced = videoStream.disposition.forced == 1;
-                                stream.AttachedPic = videoStream.disposition.attached_pic == 1;
-                            }
-
-                            version.Streams.Add(stream);
-                        }
-
-                        foreach (FFprobeStream subtitleStream in json.streams.Filter(s => s.codec_type == "subtitle"))
-                        {
-                            var stream = new MediaStream
-                            {
-                                MediaVersionId = version.Id,
-                                MediaStreamKind = MediaStreamKind.Subtitle,
-                                Index = subtitleStream.index,
-                                Codec = subtitleStream.codec_name
-                            };
-
-                            if (subtitleStream.disposition is not null)
-                            {
-                                stream.Default = subtitleStream.disposition.@default == 1;
-                                stream.Forced = subtitleStream.disposition.forced == 1;
-                            }
-
-                            if (subtitleStream.tags is not null)
-                            {
-                                stream.Language = subtitleStream.tags.language;
-                            }
-
-                            version.Streams.Add(stream);
-                        }
-
-                        foreach (FFprobeChapter probedChapter in json.chapters)
-                        {
-                            if (double.TryParse(
-                                    probedChapter.start_time,
-                                    NumberStyles.Number,
-                                    CultureInfo.InvariantCulture,
-                                    out double startTime)
-                                && double.TryParse(
-                                    probedChapter.end_time,
-                                    NumberStyles.Number,
-                                    CultureInfo.InvariantCulture,
-                                    out double endTime))
-                            {
-                                var chapter = new MediaChapter
-                                {
-                                    MediaVersionId = version.Id,
-                                    ChapterId = probedChapter.id,
-                                    StartTime = TimeSpan.FromSeconds(startTime),
-                                    EndTime = TimeSpan.FromSeconds(endTime),
-                                    Title = probedChapter?.tags?.title
-                                };
-
-                                version.Chapters.Add(chapter);
-                            }
-                            else
-                            {
-                                _logger.LogWarning(
-                                    "Media item at {Path} has a missing or invalid chapter start/end time",
-                                    path);
-                            }
-                        }
-
-                        if (version.Chapters.Any())
-                        {
-                            MediaChapter last = version.Chapters.Last();
-                            if (last.EndTime != version.Duration)
-                            {
-                                last.EndTime = version.Duration;
-                            }
-                        }
+    public async Task<Either<BaseError, Dictionary<string, string>>> GetFormatTags(
+        string ffprobePath,
+        MediaItem mediaItem)
+    {
+        try
+        {
+            string mediaItemPath = mediaItem.GetHeadVersion().MediaFiles.Head().Path;
+            Either<BaseError, FFprobe> maybeProbe = await GetProbeOutput(ffprobePath, mediaItemPath);
+            return maybeProbe.Match(
+                ffprobe =>
+                {
+                    var result = new Dictionary<string, string>();
                         
-                        return version;
-                    },
-                    _ => new MediaVersion
+                    if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.album))
+                    {
+                        result.Add(MetadataFormatTag.Album, ffprobe.format.tags.album);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.artist))
+                    {
+                        result.Add(MetadataFormatTag.Artist, ffprobe.format.tags.artist);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.date))
+                    {
+                        result.Add(MetadataFormatTag.Date, ffprobe.format.tags.date);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.genre))
+                    {
+                        result.Add(MetadataFormatTag.Genre, ffprobe.format.tags.genre);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.title))
+                    {
+                        result.Add(MetadataFormatTag.Title, ffprobe.format.tags.title);
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(ffprobe?.format?.tags?.track))
+                    {
+                        result.Add(MetadataFormatTag.Track, ffprobe.format.tags.track);
+                    }
+
+                    return Right<BaseError, Dictionary<string, string>>(result);
+                },
+                Left<BaseError, Dictionary<string, string>>);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to get format tags for media item {Id}", mediaItem.Id);
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    private async Task<bool> ApplyVersionUpdate(MediaItem mediaItem, MediaVersion version, string filePath)
+    {
+        MediaVersion mediaItemVersion = mediaItem.GetHeadVersion();
+
+        bool durationChange = mediaItemVersion.Duration != version.Duration;
+
+        version.DateUpdated = _localFileSystem.GetLastWriteTime(filePath);
+
+        return await _metadataRepository.UpdateLocalStatistics(mediaItem, version) && durationChange;
+    }
+
+    private Task<Either<BaseError, FFprobe>> GetProbeOutput(string ffprobePath, string filePath)
+    {
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = ffprobePath,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            StandardOutputEncoding = Encoding.UTF8,
+            StandardErrorEncoding = Encoding.UTF8
+        };
+
+        startInfo.ArgumentList.Add("-v");
+        startInfo.ArgumentList.Add("quiet");
+        startInfo.ArgumentList.Add("-print_format");
+        startInfo.ArgumentList.Add("json");
+        startInfo.ArgumentList.Add("-show_format");
+        startInfo.ArgumentList.Add("-show_streams");
+        startInfo.ArgumentList.Add("-show_chapters");
+        startInfo.ArgumentList.Add("-i");
+        startInfo.ArgumentList.Add(filePath);
+
+        var probe = new Process
+        {
+            StartInfo = startInfo
+        };
+
+        probe.Start();
+        return probe.StandardOutput.ReadToEndAsync().MapAsync<string, Either<BaseError, FFprobe>>(
+            async output =>
+            {
+                await probe.WaitForExitAsync();
+                return probe.ExitCode == 0
+                    ? JsonConvert.DeserializeObject<FFprobe>(output)
+                    : BaseError.New($"FFprobe at {ffprobePath} exited with code {probe.ExitCode}");
+            });
+    }
+
+    internal MediaVersion ProjectToMediaVersion(string path, FFprobe probeOutput) =>
+        Optional(probeOutput)
+            .Filter(json => json?.format != null && json.streams != null)
+            .ToValidation<BaseError>("Unable to parse ffprobe output")
+            .ToEither<FFprobe>()
+            .Match(
+                json =>
+                {
+                    var version = new MediaVersion
                     {
                         Name = "Main",
                         DateAdded = DateTime.UtcNow,
                         Streams = new List<MediaStream>(),
                         Chapters = new List<MediaChapter>()
-                    });
+                    };
 
-        private VideoScanKind ScanKindFromFieldOrder(string fieldOrder) =>
-            fieldOrder?.ToLowerInvariant() switch
-            {
-                var x when x == "tt" || x == "bb" || x == "tb" || x == "bt" => VideoScanKind.Interlaced,
-                "progressive" => VideoScanKind.Progressive,
-                _ => VideoScanKind.Unknown
-            };
+                    if (double.TryParse(
+                            json.format.duration,
+                            NumberStyles.Number,
+                            CultureInfo.InvariantCulture,
+                            out double duration))
+                    {
+                        var seconds = TimeSpan.FromSeconds(duration);
+                        version.Duration = seconds;
+                    }
+                    else
+                    {
+                        _logger.LogWarning(
+                            "Media item at {Path} has a missing or invalid duration {Duration} and will cause scheduling issues",
+                            path,
+                            json.format.duration);
+                    }
 
-        // ReSharper disable InconsistentNaming
-        public record FFprobe(FFprobeFormat format, List<FFprobeStream> streams, List<FFprobeChapter> chapters);
+                    foreach (FFprobeStream audioStream in json.streams.Filter(s => s.codec_type == "audio"))
+                    {
+                        var stream = new MediaStream
+                        {
+                            MediaVersionId = version.Id,
+                            MediaStreamKind = MediaStreamKind.Audio,
+                            Index = audioStream.index,
+                            Codec = audioStream.codec_name,
+                            Profile = (audioStream.profile ?? string.Empty).ToLowerInvariant(),
+                            Channels = audioStream.channels
+                        };
 
-        public record FFprobeFormat(string duration, FFprobeFormatTags tags);
+                        if (audioStream.disposition is not null)
+                        {
+                            stream.Default = audioStream.disposition.@default == 1;
+                            stream.Forced = audioStream.disposition.forced == 1;
+                        }
 
-        public record FFprobeDisposition(int @default, int forced, int attached_pic);
+                        if (audioStream.tags is not null)
+                        {
+                            stream.Language = audioStream.tags.language;
+                            stream.Title = audioStream.tags.title;
+                        }
 
-        public record FFprobeTags(string language, string title);
+                        version.Streams.Add(stream);
+                    }
 
-        public record FFprobeFormatTags(
-            string title,
-            string artist,
-            string album,
-            string track,
-            string genre,
-            string date);
+                    FFprobeStream videoStream = json.streams.FirstOrDefault(s => s.codec_type == "video");
+                    if (videoStream != null)
+                    {
+                        version.SampleAspectRatio = string.IsNullOrWhiteSpace(videoStream.sample_aspect_ratio)
+                            ? "1:1"
+                            : videoStream.sample_aspect_ratio;
+                        version.DisplayAspectRatio = videoStream.display_aspect_ratio;
+                        version.Width = videoStream.width;
+                        version.Height = videoStream.height;
+                        version.VideoScanKind = ScanKindFromFieldOrder(videoStream.field_order);
+                        version.RFrameRate = videoStream.r_frame_rate;
 
-        public record FFprobeStream(
-            int index,
-            string codec_name,
-            string profile,
-            string codec_type,
-            int channels,
-            int width,
-            int height,
-            string sample_aspect_ratio,
-            string display_aspect_ratio,
-            string pix_fmt,
-            string field_order,
-            string r_frame_rate,
-            string bits_per_raw_sample,
-            FFprobeDisposition disposition,
-            FFprobeTags tags);
+                        var stream = new MediaStream
+                        {
+                            MediaVersionId = version.Id,
+                            MediaStreamKind = MediaStreamKind.Video,
+                            Index = videoStream.index,
+                            Codec = videoStream.codec_name,
+                            Profile = (videoStream.profile ?? string.Empty).ToLowerInvariant(),
+                            PixelFormat = (videoStream.pix_fmt ?? string.Empty).ToLowerInvariant(),
+                        };
 
-        public record FFprobeChapter(
-            long id,
-            string start_time,
-            string end_time,
-            FFprobeTags tags);
-        // ReSharper restore InconsistentNaming
-    }
-}
+                        if (int.TryParse(videoStream.bits_per_raw_sample, out int bitsPerRawSample))
+                        {
+                            stream.BitsPerRawSample = bitsPerRawSample;
+                        }
+
+                        if (videoStream.disposition is not null)
+                        {
+                            stream.Default = videoStream.disposition.@default == 1;
+                            stream.Forced = videoStream.disposition.forced == 1;
+                            stream.AttachedPic = videoStream.disposition.attached_pic == 1;
+                        }
+
+                        version.Streams.Add(stream);
+                    }
+
+                    foreach (FFprobeStream subtitleStream in json.streams.Filter(s => s.codec_type == "subtitle"))
+                    {
+                        var stream = new MediaStream
+                        {
+                            MediaVersionId = version.Id,
+                            MediaStreamKind = MediaStreamKind.Subtitle,
+                            Index = subtitleStream.index,
+                            Codec = subtitleStream.codec_name
+                        };
+
+                        if (subtitleStream.disposition is not null)
+                        {
+                            stream.Default = subtitleStream.disposition.@default == 1;
+                            stream.Forced = subtitleStream.disposition.forced == 1;
+                        }
+
+                        if (subtitleStream.tags is not null)
+                        {
+                            stream.Language = subtitleStream.tags.language;
+                        }
+
+                        version.Streams.Add(stream);
+                    }
+
+                    foreach (FFprobeChapter probedChapter in json.chapters)
+                    {
+                        if (double.TryParse(
+                                probedChapter.start_time,
+                                NumberStyles.Number,
+                                CultureInfo.InvariantCulture,
+                                out double startTime)
+                            && double.TryParse(
+                                probedChapter.end_time,
+                                NumberStyles.Number,
+                                CultureInfo.InvariantCulture,
+                                out double endTime))
+                        {
+                            var chapter = new MediaChapter
+                            {
+                                MediaVersionId = version.Id,
+                                ChapterId = probedChapter.id,
+                                StartTime = TimeSpan.FromSeconds(startTime),
+                                EndTime = TimeSpan.FromSeconds(endTime),
+                                Title = probedChapter?.tags?.title
+                            };
+
+                            version.Chapters.Add(chapter);
+                        }
+                        else
+                        {
+                            _logger.LogWarning(
+                                "Media item at {Path} has a missing or invalid chapter start/end time",
+                                path);
+                        }
+                    }
+
+                    if (version.Chapters.Any())
+                    {
+                        MediaChapter last = version.Chapters.Last();
+                        if (last.EndTime != version.Duration)
+                        {
+                            last.EndTime = version.Duration;
+                        }
+                    }
+                        
+                    return version;
+                },
+                _ => new MediaVersion
+                {
+                    Name = "Main",
+                    DateAdded = DateTime.UtcNow,
+                    Streams = new List<MediaStream>(),
+                    Chapters = new List<MediaChapter>()
+                });
+
+    private VideoScanKind ScanKindFromFieldOrder(string fieldOrder) =>
+        fieldOrder?.ToLowerInvariant() switch
+        {
+            var x when x == "tt" || x == "bb" || x == "tb" || x == "bt" => VideoScanKind.Interlaced,
+            "progressive" => VideoScanKind.Progressive,
+            _ => VideoScanKind.Unknown
+        };
+
+    // ReSharper disable InconsistentNaming
+    public record FFprobe(FFprobeFormat format, List<FFprobeStream> streams, List<FFprobeChapter> chapters);
+
+    public record FFprobeFormat(string duration, FFprobeFormatTags tags);
+
+    public record FFprobeDisposition(int @default, int forced, int attached_pic);
+
+    public record FFprobeTags(string language, string title);
+
+    public record FFprobeFormatTags(
+        string title,
+        string artist,
+        string album,
+        string track,
+        string genre,
+        string date);
+
+    public record FFprobeStream(
+        int index,
+        string codec_name,
+        string profile,
+        string codec_type,
+        int channels,
+        int width,
+        int height,
+        string sample_aspect_ratio,
+        string display_aspect_ratio,
+        string pix_fmt,
+        string field_order,
+        string r_frame_rate,
+        string bits_per_raw_sample,
+        FFprobeDisposition disposition,
+        FFprobeTags tags);
+
+    public record FFprobeChapter(
+        long id,
+        string start_time,
+        string end_time,
+        FFprobeTags tags);
+    // ReSharper restore InconsistentNaming
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/MediaItemScanResult.cs b/ErsatzTV.Core/Metadata/MediaItemScanResult.cs
index a3520e97b..ae5dc61dc 100644
--- a/ErsatzTV.Core/Metadata/MediaItemScanResult.cs
+++ b/ErsatzTV.Core/Metadata/MediaItemScanResult.cs
@@ -1,14 +1,13 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class MediaItemScanResult<T> where T : MediaItem
 {
-    public class MediaItemScanResult<T> where T : MediaItem
-    {
-        public MediaItemScanResult(T item) => Item = item;
+    public MediaItemScanResult(T item) => Item = item;
 
-        public T Item { get; set; }
+    public T Item { get; set; }
 
-        public bool IsAdded { get; set; }
-        public bool IsUpdated { get; set; }
-    }
-}
+    public bool IsAdded { get; set; }
+    public bool IsUpdated { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/MetadataFormatTag.cs b/ErsatzTV.Core/Metadata/MetadataFormatTag.cs
index 1ce676f6a..3562f3799 100644
--- a/ErsatzTV.Core/Metadata/MetadataFormatTag.cs
+++ b/ErsatzTV.Core/Metadata/MetadataFormatTag.cs
@@ -1,12 +1,11 @@
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public static class MetadataFormatTag
 {
-    public static class MetadataFormatTag
-    {
-        public static readonly string Album = "album";
-        public static readonly string Artist = "artist";
-        public static readonly string Date = "date";
-        public static readonly string Genre = "genre";
-        public static readonly string Title = "title";
-        public static readonly string Track = "track";
-    }
-}
+    public static readonly string Album = "album";
+    public static readonly string Artist = "artist";
+    public static readonly string Date = "date";
+    public static readonly string Genre = "genre";
+    public static readonly string Title = "title";
+    public static readonly string Track = "track";
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/MovieFolderScanner.cs b/ErsatzTV.Core/Metadata/MovieFolderScanner.cs
index 7fc24f123..cb76638bf 100644
--- a/ErsatzTV.Core/Metadata/MovieFolderScanner.cs
+++ b/ErsatzTV.Core/Metadata/MovieFolderScanner.cs
@@ -1,289 +1,280 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 using Seq = LanguageExt.Seq;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class MovieFolderScanner : LocalFolderScanner, IMovieFolderScanner
 {
-    public class MovieFolderScanner : LocalFolderScanner, IMovieFolderScanner
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalMetadataProvider _localMetadataProvider;
+    private readonly ILogger<MovieFolderScanner> _logger;
+    private readonly IMediator _mediator;
+    private readonly IMovieRepository _movieRepository;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+
+    public MovieFolderScanner(
+        ILocalFileSystem localFileSystem,
+        IMovieRepository movieRepository,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILocalMetadataProvider localMetadataProvider,
+        IMetadataRepository metadataRepository,
+        IImageCache imageCache,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        ILibraryRepository libraryRepository,
+        IMediaItemRepository mediaItemRepository,
+        IMediator mediator,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
+        ITempFilePool tempFilePool,
+        ILogger<MovieFolderScanner> logger)
+        : base(
+            localFileSystem,
+            localStatisticsProvider,
+            metadataRepository,
+            mediaItemRepository,
+            imageCache,
+            ffmpegProcessServiceFactory,
+            tempFilePool,
+            logger)
     {
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalMetadataProvider _localMetadataProvider;
-        private readonly ILogger<MovieFolderScanner> _logger;
-        private readonly IMediator _mediator;
-        private readonly IMovieRepository _movieRepository;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
+        _localFileSystem = localFileSystem;
+        _movieRepository = movieRepository;
+        _localMetadataProvider = localMetadataProvider;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _libraryRepository = libraryRepository;
+        _mediator = mediator;
+        _logger = logger;
+    }
 
-        public MovieFolderScanner(
-            ILocalFileSystem localFileSystem,
-            IMovieRepository movieRepository,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILocalMetadataProvider localMetadataProvider,
-            IMetadataRepository metadataRepository,
-            IImageCache imageCache,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            ILibraryRepository libraryRepository,
-            IMediaItemRepository mediaItemRepository,
-            IMediator mediator,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
-            ITempFilePool tempFilePool,
-            ILogger<MovieFolderScanner> logger)
-            : base(
-                localFileSystem,
-                localStatisticsProvider,
-                metadataRepository,
-                mediaItemRepository,
-                imageCache,
-                ffmpegProcessServiceFactory,
-                tempFilePool,
-                logger)
+    public async Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        decimal progressMin,
+        decimal progressMax)
+    {
+        decimal progressSpread = progressMax - progressMin;
+
+        var foldersCompleted = 0;
+
+        var folderQueue = new Queue<string>();
+        foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path)
+                     .Filter(ShouldIncludeFolder)
+                     .OrderBy(identity))
         {
-            _localFileSystem = localFileSystem;
-            _movieRepository = movieRepository;
-            _localMetadataProvider = localMetadataProvider;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _libraryRepository = libraryRepository;
-            _mediator = mediator;
-            _logger = logger;
+            folderQueue.Enqueue(folder);
         }
 
-        public async Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            decimal progressMin,
-            decimal progressMax)
+        while (folderQueue.Count > 0)
         {
-            decimal progressSpread = progressMax - progressMin;
+            decimal percentCompletion = (decimal) foldersCompleted / (foldersCompleted + folderQueue.Count);
+            await _mediator.Publish(
+                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
 
-            var foldersCompleted = 0;
+            string movieFolder = folderQueue.Dequeue();
+            foldersCompleted++;
 
-            var folderQueue = new Queue<string>();
-            foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path)
-                .Filter(ShouldIncludeFolder)
-                .OrderBy(identity))
+            var filesForEtag = _localFileSystem.ListFiles(movieFolder).ToList();
+
+            var allFiles = filesForEtag
+                .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
+                .Filter(f => !Path.GetFileName(f).StartsWith("._"))
+                .Filter(
+                    f => !ExtraFiles.Any(
+                        e => Path.GetFileNameWithoutExtension(f).EndsWith(e, StringComparison.OrdinalIgnoreCase)))
+                .ToList();
+
+            if (allFiles.Count == 0)
             {
-                folderQueue.Enqueue(folder);
-            }
-
-            while (folderQueue.Count > 0)
-            {
-                decimal percentCompletion = (decimal) foldersCompleted / (foldersCompleted + folderQueue.Count);
-                await _mediator.Publish(
-                    new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
-
-                string movieFolder = folderQueue.Dequeue();
-                foldersCompleted++;
-
-                var filesForEtag = _localFileSystem.ListFiles(movieFolder).ToList();
-
-                var allFiles = filesForEtag
-                    .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
-                    .Filter(f => !Path.GetFileName(f).StartsWith("._"))
-                    .Filter(
-                        f => !ExtraFiles.Any(
-                            e => Path.GetFileNameWithoutExtension(f).EndsWith(e, StringComparison.OrdinalIgnoreCase)))
-                    .ToList();
-
-                if (allFiles.Count == 0)
+                foreach (string subdirectory in _localFileSystem.ListSubdirectories(movieFolder)
+                             .Filter(ShouldIncludeFolder)
+                             .OrderBy(identity))
                 {
-                    foreach (string subdirectory in _localFileSystem.ListSubdirectories(movieFolder)
-                        .Filter(ShouldIncludeFolder)
-                        .OrderBy(identity))
-                    {
-                        folderQueue.Enqueue(subdirectory);
-                    }
-
-                    continue;
+                    folderQueue.Enqueue(subdirectory);
                 }
 
-                string etag = FolderEtag.Calculate(movieFolder, _localFileSystem);
-                Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
-                    .Filter(f => f.Path == movieFolder)
-                    .HeadOrNone();
-
-                // skip folder if etag matches
-                if (await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
-                {
-                    continue;
-                }
-
-                _logger.LogDebug(
-                    "UPDATE: Etag has changed for folder {Folder}",
-                    movieFolder);
-
-                foreach (string file in allFiles.OrderBy(identity))
-                {
-                    // TODO: figure out how to rebuild playlists
-                    Either<BaseError, MediaItemScanResult<Movie>> maybeMovie = await _movieRepository
-                        .GetOrAdd(libraryPath, file)
-                        .BindT(movie => UpdateStatistics(movie, ffprobePath))
-                        .BindT(UpdateMetadata)
-                        .BindT(movie => UpdateArtwork(movie, ArtworkKind.Poster))
-                        .BindT(movie => UpdateArtwork(movie, ArtworkKind.FanArt))
-                        .BindT(FlagNormal);
-
-                    await maybeMovie.Match(
-                        async result =>
-                        {
-                            if (result.IsAdded)
-                            {
-                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
-                            }
-                            else if (result.IsUpdated)
-                            {
-                                await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
-                            }
-
-                            await _libraryRepository.SetEtag(libraryPath, knownFolder, movieFolder, etag);
-                        },
-                        error =>
-                        {
-                            _logger.LogWarning("Error processing movie at {Path}: {Error}", file, error.Value);
-                            return Task.CompletedTask;
-                        });
-                }
+                continue;
             }
 
-            foreach (string path in await _movieRepository.FindMoviePaths(libraryPath))
-            {
-                if (!_localFileSystem.FileExists(path))
-                {
-                    _logger.LogInformation("Flagging missing movie at {Path}", path);
-                    List<int> ids = await FlagFileNotFound(libraryPath, path);
-                    await _searchIndex.RebuildItems(_searchRepository, ids);
-                }
-                else if (Path.GetFileName(path).StartsWith("._"))
-                {
-                    _logger.LogInformation("Removing dot underscore file at {Path}", path);
-                    List<int> ids = await _movieRepository.DeleteByPath(libraryPath, path);
-                    await _searchIndex.RemoveItems(ids);
-                }
-            }
-
-            await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
-
-            _searchIndex.Commit();
-            return Unit.Default;
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Movie>>> UpdateMetadata(
-            MediaItemScanResult<Movie> result)
-        {
-            try
-            {
-                Movie movie = result.Item;
-                await LocateNfoFile(movie).Match(
-                    async nfoFile =>
-                    {
-                        bool shouldUpdate = Optional(movie.MovieMetadata).Flatten().HeadOrNone().Match(
-                            m => m.MetadataKind == MetadataKind.Fallback ||
-                                 m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
-                            true);
-
-                        if (shouldUpdate)
-                        {
-                            _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
-                            if (await _localMetadataProvider.RefreshSidecarMetadata(movie, nfoFile))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-                    },
-                    async () =>
-                    {
-                        if (!Optional(movie.MovieMetadata).Flatten().Any())
-                        {
-                            string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
-                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
-                            if (await _localMetadataProvider.RefreshFallbackMetadata(movie))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-                    });
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Movie>>> UpdateArtwork(
-            MediaItemScanResult<Movie> result,
-            ArtworkKind artworkKind)
-        {
-            try
-            {
-                Movie movie = result.Item;
-                await LocateArtwork(movie, artworkKind).IfSomeAsync(
-                    async posterFile =>
-                    {
-                        MovieMetadata metadata = movie.MovieMetadata.Head();
-                        await RefreshArtwork(posterFile, metadata, artworkKind, None, None);
-                    });
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private Option<string> LocateNfoFile(Movie movie)
-        {
-            string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
-            string movieAsNfo = Path.ChangeExtension(path, "nfo");
-            string movieNfo = Path.Combine(Path.GetDirectoryName(path) ?? string.Empty, "movie.nfo");
-            return Seq.create(movieAsNfo, movieNfo)
-                .Filter(s => _localFileSystem.FileExists(s))
+            string etag = FolderEtag.Calculate(movieFolder, _localFileSystem);
+            Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
+                .Filter(f => f.Path == movieFolder)
                 .HeadOrNone();
+
+            // skip folder if etag matches
+            if (await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
+            {
+                continue;
+            }
+
+            _logger.LogDebug(
+                "UPDATE: Etag has changed for folder {Folder}",
+                movieFolder);
+
+            foreach (string file in allFiles.OrderBy(identity))
+            {
+                // TODO: figure out how to rebuild playlists
+                Either<BaseError, MediaItemScanResult<Movie>> maybeMovie = await _movieRepository
+                    .GetOrAdd(libraryPath, file)
+                    .BindT(movie => UpdateStatistics(movie, ffprobePath))
+                    .BindT(UpdateMetadata)
+                    .BindT(movie => UpdateArtwork(movie, ArtworkKind.Poster))
+                    .BindT(movie => UpdateArtwork(movie, ArtworkKind.FanArt))
+                    .BindT(FlagNormal);
+
+                await maybeMovie.Match(
+                    async result =>
+                    {
+                        if (result.IsAdded)
+                        {
+                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                        }
+                        else if (result.IsUpdated)
+                        {
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
+                        }
+
+                        await _libraryRepository.SetEtag(libraryPath, knownFolder, movieFolder, etag);
+                    },
+                    error =>
+                    {
+                        _logger.LogWarning("Error processing movie at {Path}: {Error}", file, error.Value);
+                        return Task.CompletedTask;
+                    });
+            }
         }
 
-        private Option<string> LocateArtwork(Movie movie, ArtworkKind artworkKind)
+        foreach (string path in await _movieRepository.FindMoviePaths(libraryPath))
         {
-            string segment = artworkKind switch
+            if (!_localFileSystem.FileExists(path))
             {
-                ArtworkKind.Poster => "poster",
-                ArtworkKind.FanArt => "fanart",
-                _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
-            };
-
-            string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
-            string folder = Path.GetDirectoryName(path) ?? string.Empty;
-            IEnumerable<string> possibleMoviePosters = ImageFileExtensions.Collect(
-                    ext => new[] { $"{segment}.{ext}", Path.GetFileNameWithoutExtension(path) + $"-{segment}.{ext}" })
-                .Map(f => Path.Combine(folder, f));
-            Option<string> result = possibleMoviePosters.Filter(p => _localFileSystem.FileExists(p)).HeadOrNone();
-            if (result.IsNone && artworkKind == ArtworkKind.Poster)
-            {
-                IEnumerable<string> possibleFolderPosters = ImageFileExtensions.Collect(
-                        ext => new[] { $"folder.{ext}" })
-                    .Map(f => Path.Combine(folder, f));
-                result = possibleFolderPosters.Filter(p => _localFileSystem.FileExists(p)).HeadOrNone();
+                _logger.LogInformation("Flagging missing movie at {Path}", path);
+                List<int> ids = await FlagFileNotFound(libraryPath, path);
+                await _searchIndex.RebuildItems(_searchRepository, ids);
             }
+            else if (Path.GetFileName(path).StartsWith("._"))
+            {
+                _logger.LogInformation("Removing dot underscore file at {Path}", path);
+                List<int> ids = await _movieRepository.DeleteByPath(libraryPath, path);
+                await _searchIndex.RemoveItems(ids);
+            }
+        }
+
+        await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
+
+        _searchIndex.Commit();
+        return Unit.Default;
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<Movie>>> UpdateMetadata(
+        MediaItemScanResult<Movie> result)
+    {
+        try
+        {
+            Movie movie = result.Item;
+            await LocateNfoFile(movie).Match(
+                async nfoFile =>
+                {
+                    bool shouldUpdate = Optional(movie.MovieMetadata).Flatten().HeadOrNone().Match(
+                        m => m.MetadataKind == MetadataKind.Fallback ||
+                             m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
+                        true);
+
+                    if (shouldUpdate)
+                    {
+                        _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
+                        if (await _localMetadataProvider.RefreshSidecarMetadata(movie, nfoFile))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+                },
+                async () =>
+                {
+                    if (!Optional(movie.MovieMetadata).Flatten().Any())
+                    {
+                        string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
+                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
+                        if (await _localMetadataProvider.RefreshFallbackMetadata(movie))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+                });
 
             return result;
         }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
     }
-}
+
+    private async Task<Either<BaseError, MediaItemScanResult<Movie>>> UpdateArtwork(
+        MediaItemScanResult<Movie> result,
+        ArtworkKind artworkKind)
+    {
+        try
+        {
+            Movie movie = result.Item;
+            await LocateArtwork(movie, artworkKind).IfSomeAsync(
+                async posterFile =>
+                {
+                    MovieMetadata metadata = movie.MovieMetadata.Head();
+                    await RefreshArtwork(posterFile, metadata, artworkKind, None, None);
+                });
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private Option<string> LocateNfoFile(Movie movie)
+    {
+        string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
+        string movieAsNfo = Path.ChangeExtension(path, "nfo");
+        string movieNfo = Path.Combine(Path.GetDirectoryName(path) ?? string.Empty, "movie.nfo");
+        return Seq.create(movieAsNfo, movieNfo)
+            .Filter(s => _localFileSystem.FileExists(s))
+            .HeadOrNone();
+    }
+
+    private Option<string> LocateArtwork(Movie movie, ArtworkKind artworkKind)
+    {
+        string segment = artworkKind switch
+        {
+            ArtworkKind.Poster => "poster",
+            ArtworkKind.FanArt => "fanart",
+            _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
+        };
+
+        string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
+        string folder = Path.GetDirectoryName(path) ?? string.Empty;
+        IEnumerable<string> possibleMoviePosters = ImageFileExtensions.Collect(
+                ext => new[] { $"{segment}.{ext}", Path.GetFileNameWithoutExtension(path) + $"-{segment}.{ext}" })
+            .Map(f => Path.Combine(folder, f));
+        Option<string> result = possibleMoviePosters.Filter(p => _localFileSystem.FileExists(p)).HeadOrNone();
+        if (result.IsNone && artworkKind == ArtworkKind.Poster)
+        {
+            IEnumerable<string> possibleFolderPosters = ImageFileExtensions.Collect(
+                    ext => new[] { $"folder.{ext}" })
+                .Map(f => Path.Combine(folder, f));
+            result = possibleFolderPosters.Filter(p => _localFileSystem.FileExists(p)).HeadOrNone();
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/MusicVideoFolderScanner.cs b/ErsatzTV.Core/Metadata/MusicVideoFolderScanner.cs
index 7ed385d77..e7c87ba12 100644
--- a/ErsatzTV.Core/Metadata/MusicVideoFolderScanner.cs
+++ b/ErsatzTV.Core/Metadata/MusicVideoFolderScanner.cs
@@ -1,107 +1,278 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class MusicVideoFolderScanner : LocalFolderScanner, IMusicVideoFolderScanner
 {
-    public class MusicVideoFolderScanner : LocalFolderScanner, IMusicVideoFolderScanner
-    {
-        private readonly IArtistRepository _artistRepository;
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalMetadataProvider _localMetadataProvider;
-        private readonly ILogger<MusicVideoFolderScanner> _logger;
-        private readonly IMediator _mediator;
-        private readonly IMusicVideoRepository _musicVideoRepository;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
+    private readonly IArtistRepository _artistRepository;
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalMetadataProvider _localMetadataProvider;
+    private readonly ILogger<MusicVideoFolderScanner> _logger;
+    private readonly IMediator _mediator;
+    private readonly IMusicVideoRepository _musicVideoRepository;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
 
-        public MusicVideoFolderScanner(
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILocalMetadataProvider localMetadataProvider,
-            IMetadataRepository metadataRepository,
-            IImageCache imageCache,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            IArtistRepository artistRepository,
-            IMusicVideoRepository musicVideoRepository,
-            ILibraryRepository libraryRepository,
-            IMediaItemRepository mediaItemRepository,
-            IMediator mediator,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
-            ITempFilePool tempFilePool,
-            ILogger<MusicVideoFolderScanner> logger) : base(
-            localFileSystem,
-            localStatisticsProvider,
-            metadataRepository,
-            mediaItemRepository,
-            imageCache,
-            ffmpegProcessServiceFactory,
-            tempFilePool,
-            logger)
+    public MusicVideoFolderScanner(
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILocalMetadataProvider localMetadataProvider,
+        IMetadataRepository metadataRepository,
+        IImageCache imageCache,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        IArtistRepository artistRepository,
+        IMusicVideoRepository musicVideoRepository,
+        ILibraryRepository libraryRepository,
+        IMediaItemRepository mediaItemRepository,
+        IMediator mediator,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
+        ITempFilePool tempFilePool,
+        ILogger<MusicVideoFolderScanner> logger) : base(
+        localFileSystem,
+        localStatisticsProvider,
+        metadataRepository,
+        mediaItemRepository,
+        imageCache,
+        ffmpegProcessServiceFactory,
+        tempFilePool,
+        logger)
+    {
+        _localFileSystem = localFileSystem;
+        _localMetadataProvider = localMetadataProvider;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _artistRepository = artistRepository;
+        _musicVideoRepository = musicVideoRepository;
+        _libraryRepository = libraryRepository;
+        _mediator = mediator;
+        _logger = logger;
+    }
+
+    public async Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        decimal progressMin,
+        decimal progressMax)
+    {
+        decimal progressSpread = progressMax - progressMin;
+
+        var allArtistFolders = _localFileSystem.ListSubdirectories(libraryPath.Path)
+            .Filter(ShouldIncludeFolder)
+            .OrderBy(identity)
+            .ToList();
+
+        foreach (string artistFolder in allArtistFolders)
         {
-            _localFileSystem = localFileSystem;
-            _localMetadataProvider = localMetadataProvider;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _artistRepository = artistRepository;
-            _musicVideoRepository = musicVideoRepository;
-            _libraryRepository = libraryRepository;
-            _mediator = mediator;
-            _logger = logger;
+            // _logger.LogDebug("Scanning artist folder {Folder}", artistFolder);
+
+            decimal percentCompletion = (decimal) allArtistFolders.IndexOf(artistFolder) / allArtistFolders.Count;
+            await _mediator.Publish(
+                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
+
+            Either<BaseError, MediaItemScanResult<Artist>> maybeArtist =
+                await FindOrCreateArtist(libraryPath.Id, artistFolder)
+                    .BindT(artist => UpdateMetadataForArtist(artist, artistFolder))
+                    .BindT(artist => UpdateArtworkForArtist(artist, artistFolder, ArtworkKind.Thumbnail))
+                    .BindT(artist => UpdateArtworkForArtist(artist, artistFolder, ArtworkKind.FanArt));
+
+            await maybeArtist.Match(
+                async result =>
+                {
+                    await ScanMusicVideos(
+                        libraryPath,
+                        ffprobePath,
+                        result.Item,
+                        artistFolder);
+
+                    if (result.IsAdded)
+                    {
+                        await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                    }
+                    else if (result.IsUpdated)
+                    {
+                        await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
+                    }
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Error processing artist in folder {Folder}: {Error}",
+                        artistFolder,
+                        error.Value);
+                    return Task.FromResult(Unit.Default);
+                });
         }
 
-        public async Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            decimal progressMin,
-            decimal progressMax)
+        foreach (string path in await _musicVideoRepository.FindOrphanPaths(libraryPath))
         {
-            decimal progressSpread = progressMax - progressMin;
+            _logger.LogInformation("Removing improperly named music video at {Path}", path);
+            List<int> musicVideoIds = await _musicVideoRepository.DeleteByPath(libraryPath, path);
+            await _searchIndex.RemoveItems(musicVideoIds);
+        }
 
-            var allArtistFolders = _localFileSystem.ListSubdirectories(libraryPath.Path)
-                .Filter(ShouldIncludeFolder)
-                .OrderBy(identity)
+        foreach (string path in await _musicVideoRepository.FindMusicVideoPaths(libraryPath))
+        {
+            if (!_localFileSystem.FileExists(path))
+            {
+                _logger.LogInformation("Flagging missing music video at {Path}", path);
+                List<int> musicVideoIds = await FlagFileNotFound(libraryPath, path);
+                await _searchIndex.RebuildItems(_searchRepository, musicVideoIds);
+            }
+            else if (Path.GetFileName(path).StartsWith("._"))
+            {
+                _logger.LogInformation("Removing dot underscore file at {Path}", path);
+                List<int> musicVideoIds = await _musicVideoRepository.DeleteByPath(libraryPath, path);
+                await _searchIndex.RemoveItems(musicVideoIds);
+            }
+        }
+            
+        await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
+
+        List<int> artistIds = await _artistRepository.DeleteEmptyArtists(libraryPath);
+        await _searchIndex.RemoveItems(artistIds);
+
+        _searchIndex.Commit();
+        return Unit.Default;
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<Artist>>> FindOrCreateArtist(
+        int libraryPathId,
+        string artistFolder)
+    {
+        ArtistMetadata metadata = await _localMetadataProvider.GetMetadataForArtist(artistFolder);
+        Option<Artist> maybeArtist = await _artistRepository.GetArtistByMetadata(libraryPathId, metadata);
+        return await maybeArtist.Match(
+            artist => Right<BaseError, MediaItemScanResult<Artist>>(new MediaItemScanResult<Artist>(artist))
+                .AsTask(),
+            async () => await _artistRepository.AddArtist(libraryPathId, artistFolder, metadata));
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<Artist>>> UpdateMetadataForArtist(
+        MediaItemScanResult<Artist> result,
+        string artistFolder)
+    {
+        try
+        {
+            Artist artist = result.Item;
+            await LocateNfoFileForArtist(artistFolder).Match(
+                async nfoFile =>
+                {
+                    bool shouldUpdate = Optional(artist.ArtistMetadata).Flatten().HeadOrNone().Match(
+                        m => m.MetadataKind == MetadataKind.Fallback ||
+                             m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
+                        true);
+
+                    if (shouldUpdate)
+                    {
+                        _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
+                        if (await _localMetadataProvider.RefreshSidecarMetadata(artist, nfoFile))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+                },
+                async () =>
+                {
+                    if (!Optional(artist.ArtistMetadata).Flatten().Any())
+                    {
+                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", artistFolder);
+                        if (await _localMetadataProvider.RefreshFallbackMetadata(artist, artistFolder))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+                });
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<Artist>>> UpdateArtworkForArtist(
+        MediaItemScanResult<Artist> result,
+        string artistFolder,
+        ArtworkKind artworkKind)
+    {
+        try
+        {
+            Artist artist = result.Item;
+            await LocateArtworkForArtist(artistFolder, artworkKind).IfSomeAsync(
+                async artworkFile =>
+                {
+                    ArtistMetadata metadata = artist.ArtistMetadata.Head();
+                    await RefreshArtwork(artworkFile, metadata, artworkKind, None, None);
+                });
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private async Task ScanMusicVideos(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        Artist artist,
+        string artistFolder)
+    {
+        var folderQueue = new Queue<string>();
+        folderQueue.Enqueue(artistFolder);
+
+        while (folderQueue.Count > 0)
+        {
+            string musicVideoFolder = folderQueue.Dequeue();
+            // _logger.LogDebug("Scanning music video folder {Folder}", musicVideoFolder);
+
+            var allFiles = _localFileSystem.ListFiles(musicVideoFolder)
+                .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
+                .Filter(f => !Path.GetFileName(f).StartsWith("._"))
                 .ToList();
 
-            foreach (string artistFolder in allArtistFolders)
+            foreach (string subdirectory in _localFileSystem.ListSubdirectories(musicVideoFolder)
+                         .OrderBy(identity))
             {
-                // _logger.LogDebug("Scanning artist folder {Folder}", artistFolder);
+                folderQueue.Enqueue(subdirectory);
+            }
 
-                decimal percentCompletion = (decimal) allArtistFolders.IndexOf(artistFolder) / allArtistFolders.Count;
-                await _mediator.Publish(
-                    new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
+            string etag = FolderEtag.Calculate(musicVideoFolder, _localFileSystem);
+            Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
+                .Filter(f => f.Path == musicVideoFolder)
+                .HeadOrNone();
 
-                Either<BaseError, MediaItemScanResult<Artist>> maybeArtist =
-                    await FindOrCreateArtist(libraryPath.Id, artistFolder)
-                        .BindT(artist => UpdateMetadataForArtist(artist, artistFolder))
-                        .BindT(artist => UpdateArtworkForArtist(artist, artistFolder, ArtworkKind.Thumbnail))
-                        .BindT(artist => UpdateArtworkForArtist(artist, artistFolder, ArtworkKind.FanArt));
+            // skip folder if etag matches
+            if (await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
+            {
+                continue;
+            }
 
-                await maybeArtist.Match(
+            foreach (string file in allFiles.OrderBy(identity))
+            {
+                // TODO: figure out how to rebuild playouts
+                Either<BaseError, MediaItemScanResult<MusicVideo>> maybeMusicVideo = await _musicVideoRepository
+                    .GetOrAdd(artist, libraryPath, file)
+                    .BindT(musicVideo => UpdateStatistics(musicVideo, ffprobePath))
+                    .BindT(UpdateMetadata)
+                    .BindT(UpdateThumbnail)
+                    .BindT(FlagNormal);
+
+                await maybeMusicVideo.Match(
                     async result =>
                     {
-                        await ScanMusicVideos(
-                            libraryPath,
-                            ffprobePath,
-                            result.Item,
-                            artistFolder);
-
                         if (result.IsAdded)
                         {
                             await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
@@ -110,299 +281,119 @@ namespace ErsatzTV.Core.Metadata
                         {
                             await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
                         }
+
+                        await _libraryRepository.SetEtag(libraryPath, knownFolder, musicVideoFolder, etag);
                     },
                     error =>
                     {
-                        _logger.LogWarning(
-                            "Error processing artist in folder {Folder}: {Error}",
-                            artistFolder,
-                            error.Value);
-                        return Task.FromResult(Unit.Default);
+                        _logger.LogWarning("Error processing music video at {Path}: {Error}", file, error.Value);
+                        return Task.CompletedTask;
                     });
             }
-
-            foreach (string path in await _musicVideoRepository.FindOrphanPaths(libraryPath))
-            {
-                _logger.LogInformation("Removing improperly named music video at {Path}", path);
-                List<int> musicVideoIds = await _musicVideoRepository.DeleteByPath(libraryPath, path);
-                await _searchIndex.RemoveItems(musicVideoIds);
-            }
-
-            foreach (string path in await _musicVideoRepository.FindMusicVideoPaths(libraryPath))
-            {
-                if (!_localFileSystem.FileExists(path))
-                {
-                    _logger.LogInformation("Flagging missing music video at {Path}", path);
-                    List<int> musicVideoIds = await FlagFileNotFound(libraryPath, path);
-                    await _searchIndex.RebuildItems(_searchRepository, musicVideoIds);
-                }
-                else if (Path.GetFileName(path).StartsWith("._"))
-                {
-                    _logger.LogInformation("Removing dot underscore file at {Path}", path);
-                    List<int> musicVideoIds = await _musicVideoRepository.DeleteByPath(libraryPath, path);
-                    await _searchIndex.RemoveItems(musicVideoIds);
-                }
-            }
-            
-            await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
-
-            List<int> artistIds = await _artistRepository.DeleteEmptyArtists(libraryPath);
-            await _searchIndex.RemoveItems(artistIds);
-
-            _searchIndex.Commit();
-            return Unit.Default;
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Artist>>> FindOrCreateArtist(
-            int libraryPathId,
-            string artistFolder)
-        {
-            ArtistMetadata metadata = await _localMetadataProvider.GetMetadataForArtist(artistFolder);
-            Option<Artist> maybeArtist = await _artistRepository.GetArtistByMetadata(libraryPathId, metadata);
-            return await maybeArtist.Match(
-                artist => Right<BaseError, MediaItemScanResult<Artist>>(new MediaItemScanResult<Artist>(artist))
-                    .AsTask(),
-                async () => await _artistRepository.AddArtist(libraryPathId, artistFolder, metadata));
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Artist>>> UpdateMetadataForArtist(
-            MediaItemScanResult<Artist> result,
-            string artistFolder)
-        {
-            try
-            {
-                Artist artist = result.Item;
-                await LocateNfoFileForArtist(artistFolder).Match(
-                    async nfoFile =>
-                    {
-                        bool shouldUpdate = Optional(artist.ArtistMetadata).Flatten().HeadOrNone().Match(
-                            m => m.MetadataKind == MetadataKind.Fallback ||
-                                 m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
-                            true);
-
-                        if (shouldUpdate)
-                        {
-                            _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
-                            if (await _localMetadataProvider.RefreshSidecarMetadata(artist, nfoFile))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-                    },
-                    async () =>
-                    {
-                        if (!Optional(artist.ArtistMetadata).Flatten().Any())
-                        {
-                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", artistFolder);
-                            if (await _localMetadataProvider.RefreshFallbackMetadata(artist, artistFolder))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-                    });
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Artist>>> UpdateArtworkForArtist(
-            MediaItemScanResult<Artist> result,
-            string artistFolder,
-            ArtworkKind artworkKind)
-        {
-            try
-            {
-                Artist artist = result.Item;
-                await LocateArtworkForArtist(artistFolder, artworkKind).IfSomeAsync(
-                    async artworkFile =>
-                    {
-                        ArtistMetadata metadata = artist.ArtistMetadata.Head();
-                        await RefreshArtwork(artworkFile, metadata, artworkKind, None, None);
-                    });
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private async Task ScanMusicVideos(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            Artist artist,
-            string artistFolder)
-        {
-            var folderQueue = new Queue<string>();
-            folderQueue.Enqueue(artistFolder);
-
-            while (folderQueue.Count > 0)
-            {
-                string musicVideoFolder = folderQueue.Dequeue();
-                // _logger.LogDebug("Scanning music video folder {Folder}", musicVideoFolder);
-
-                var allFiles = _localFileSystem.ListFiles(musicVideoFolder)
-                    .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
-                    .Filter(f => !Path.GetFileName(f).StartsWith("._"))
-                    .ToList();
-
-                foreach (string subdirectory in _localFileSystem.ListSubdirectories(musicVideoFolder)
-                    .OrderBy(identity))
-                {
-                    folderQueue.Enqueue(subdirectory);
-                }
-
-                string etag = FolderEtag.Calculate(musicVideoFolder, _localFileSystem);
-                Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
-                    .Filter(f => f.Path == musicVideoFolder)
-                    .HeadOrNone();
-
-                // skip folder if etag matches
-                if (await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
-                {
-                    continue;
-                }
-
-                foreach (string file in allFiles.OrderBy(identity))
-                {
-                    // TODO: figure out how to rebuild playouts
-                    Either<BaseError, MediaItemScanResult<MusicVideo>> maybeMusicVideo = await _musicVideoRepository
-                        .GetOrAdd(artist, libraryPath, file)
-                        .BindT(musicVideo => UpdateStatistics(musicVideo, ffprobePath))
-                        .BindT(UpdateMetadata)
-                        .BindT(UpdateThumbnail)
-                        .BindT(FlagNormal);
-
-                    await maybeMusicVideo.Match(
-                        async result =>
-                        {
-                            if (result.IsAdded)
-                            {
-                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
-                            }
-                            else if (result.IsUpdated)
-                            {
-                                await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
-                            }
-
-                            await _libraryRepository.SetEtag(libraryPath, knownFolder, musicVideoFolder, etag);
-                        },
-                        error =>
-                        {
-                            _logger.LogWarning("Error processing music video at {Path}: {Error}", file, error.Value);
-                            return Task.CompletedTask;
-                        });
-                }
-            }
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateMetadata(
-            MediaItemScanResult<MusicVideo> result)
-        {
-            try
-            {
-                MusicVideo musicVideo = result.Item;
-                await LocateNfoFile(musicVideo).Match(
-                    async nfoFile =>
-                    {
-                        bool shouldUpdate = Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone().Match(
-                            m => m.MetadataKind == MetadataKind.Fallback ||
-                                 m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
-                            true);
-
-                        if (shouldUpdate)
-                        {
-                            _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
-                            if (await _localMetadataProvider.RefreshSidecarMetadata(musicVideo, nfoFile))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-                    },
-                    async () =>
-                    {
-                        if (!Optional(musicVideo.MusicVideoMetadata).Flatten().Any())
-                        {
-                            musicVideo.MusicVideoMetadata ??= new List<MusicVideoMetadata>();
-
-                            string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
-                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
-                            if (await _localMetadataProvider.RefreshFallbackMetadata(musicVideo))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-                    });
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private Option<string> LocateNfoFileForArtist(string artistFolder) =>
-            Optional(Path.Combine(artistFolder, "artist.nfo"))
-                .Filter(s => _localFileSystem.FileExists(s));
-
-        private Option<string> LocateArtworkForArtist(string artistFolder, ArtworkKind artworkKind)
-        {
-            string segment = artworkKind switch
-            {
-                ArtworkKind.Thumbnail => "thumb",
-                ArtworkKind.FanArt => "fanart",
-                _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
-            };
-
-            return ImageFileExtensions
-                .Map(ext => $"{segment}.{ext}")
-                .Map(f => Path.Combine(artistFolder, f))
-                .Filter(s => _localFileSystem.FileExists(s))
-                .HeadOrNone();
-        }
-
-        private Option<string> LocateNfoFile(MusicVideo musicVideo)
-        {
-            string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
-            return Optional(Path.ChangeExtension(path, "nfo"))
-                .Filter(s => _localFileSystem.FileExists(s))
-                .HeadOrNone();
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateThumbnail(
-            MediaItemScanResult<MusicVideo> result)
-        {
-            try
-            {
-                MusicVideo musicVideo = result.Item;
-                await LocateThumbnail(musicVideo).IfSomeAsync(
-                    async thumbnailFile =>
-                    {
-                        MusicVideoMetadata metadata = musicVideo.MusicVideoMetadata.Head();
-                        await RefreshArtwork(thumbnailFile, metadata, ArtworkKind.Thumbnail, None, None);
-                    });
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private Option<string> LocateThumbnail(MusicVideo musicVideo)
-        {
-            string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
-            return ImageFileExtensions
-                .Map(ext => Path.ChangeExtension(path, ext))
-                .Filter(f => _localFileSystem.FileExists(f))
-                .HeadOrNone();
         }
     }
-}
+
+    private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateMetadata(
+        MediaItemScanResult<MusicVideo> result)
+    {
+        try
+        {
+            MusicVideo musicVideo = result.Item;
+            await LocateNfoFile(musicVideo).Match(
+                async nfoFile =>
+                {
+                    bool shouldUpdate = Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone().Match(
+                        m => m.MetadataKind == MetadataKind.Fallback ||
+                             m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
+                        true);
+
+                    if (shouldUpdate)
+                    {
+                        _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
+                        if (await _localMetadataProvider.RefreshSidecarMetadata(musicVideo, nfoFile))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+                },
+                async () =>
+                {
+                    if (!Optional(musicVideo.MusicVideoMetadata).Flatten().Any())
+                    {
+                        musicVideo.MusicVideoMetadata ??= new List<MusicVideoMetadata>();
+
+                        string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
+                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
+                        if (await _localMetadataProvider.RefreshFallbackMetadata(musicVideo))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+                });
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private Option<string> LocateNfoFileForArtist(string artistFolder) =>
+        Optional(Path.Combine(artistFolder, "artist.nfo"))
+            .Filter(s => _localFileSystem.FileExists(s));
+
+    private Option<string> LocateArtworkForArtist(string artistFolder, ArtworkKind artworkKind)
+    {
+        string segment = artworkKind switch
+        {
+            ArtworkKind.Thumbnail => "thumb",
+            ArtworkKind.FanArt => "fanart",
+            _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
+        };
+
+        return ImageFileExtensions
+            .Map(ext => $"{segment}.{ext}")
+            .Map(f => Path.Combine(artistFolder, f))
+            .Filter(s => _localFileSystem.FileExists(s))
+            .HeadOrNone();
+    }
+
+    private Option<string> LocateNfoFile(MusicVideo musicVideo)
+    {
+        string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
+        return Optional(Path.ChangeExtension(path, "nfo"))
+            .Filter(s => _localFileSystem.FileExists(s))
+            .HeadOrNone();
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> UpdateThumbnail(
+        MediaItemScanResult<MusicVideo> result)
+    {
+        try
+        {
+            MusicVideo musicVideo = result.Item;
+            await LocateThumbnail(musicVideo).IfSomeAsync(
+                async thumbnailFile =>
+                {
+                    MusicVideoMetadata metadata = musicVideo.MusicVideoMetadata.Head();
+                    await RefreshArtwork(thumbnailFile, metadata, ArtworkKind.Thumbnail, None, None);
+                });
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private Option<string> LocateThumbnail(MusicVideo musicVideo)
+    {
+        string path = musicVideo.MediaVersions.Head().MediaFiles.Head().Path;
+        return ImageFileExtensions
+            .Map(ext => Path.ChangeExtension(path, ext))
+            .Filter(f => _localFileSystem.FileExists(f))
+            .HeadOrNone();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/Nfo/ActorNfo.cs b/ErsatzTV.Core/Metadata/Nfo/ActorNfo.cs
index 75a12d35c..827dbf078 100644
--- a/ErsatzTV.Core/Metadata/Nfo/ActorNfo.cs
+++ b/ErsatzTV.Core/Metadata/Nfo/ActorNfo.cs
@@ -1,19 +1,18 @@
 using System.Xml.Serialization;
 
-namespace ErsatzTV.Core.Metadata.Nfo
+namespace ErsatzTV.Core.Metadata.Nfo;
+
+public class ActorNfo
 {
-    public class ActorNfo
-    {
-        [XmlElement("name")]
-        public string Name { get; set; }
+    [XmlElement("name")]
+    public string Name { get; set; }
 
-        [XmlElement("role")]
-        public string Role { get; set; }
+    [XmlElement("role")]
+    public string Role { get; set; }
 
-        [XmlElement("order")]
-        public int? Order { get; set; }
+    [XmlElement("order")]
+    public int? Order { get; set; }
 
-        [XmlElement("thumb")]
-        public string Thumb { get; set; }
-    }
-}
+    [XmlElement("thumb")]
+    public string Thumb { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/Nfo/ArtistNfo.cs b/ErsatzTV.Core/Metadata/Nfo/ArtistNfo.cs
index 843c99571..6556717e3 100644
--- a/ErsatzTV.Core/Metadata/Nfo/ArtistNfo.cs
+++ b/ErsatzTV.Core/Metadata/Nfo/ArtistNfo.cs
@@ -1,27 +1,25 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Core.Metadata.Nfo
+namespace ErsatzTV.Core.Metadata.Nfo;
+
+[XmlRoot("artist")]
+public class ArtistNfo
 {
-    [XmlRoot("artist")]
-    public class ArtistNfo
-    {
-        [XmlElement("name")]
-        public string Name { get; set; }
+    [XmlElement("name")]
+    public string Name { get; set; }
 
-        [XmlElement("disambiguation")]
-        public string Disambiguation { get; set; }
+    [XmlElement("disambiguation")]
+    public string Disambiguation { get; set; }
 
-        [XmlElement("genre")]
-        public List<string> Genres { get; set; }
+    [XmlElement("genre")]
+    public List<string> Genres { get; set; }
 
-        [XmlElement("style")]
-        public List<string> Styles { get; set; }
+    [XmlElement("style")]
+    public List<string> Styles { get; set; }
 
-        [XmlElement("mood")]
-        public List<string> Moods { get; set; }
+    [XmlElement("mood")]
+    public List<string> Moods { get; set; }
 
-        [XmlElement("biography")]
-        public string Biography { get; set; }
-    }
-}
+    [XmlElement("biography")]
+    public string Biography { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/Nfo/EpisodeNfoReader.cs b/ErsatzTV.Core/Metadata/Nfo/EpisodeNfoReader.cs
index b2b065e24..d377541a2 100644
--- a/ErsatzTV.Core/Metadata/Nfo/EpisodeNfoReader.cs
+++ b/ErsatzTV.Core/Metadata/Nfo/EpisodeNfoReader.cs
@@ -1,201 +1,197 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using System.Xml;
+using System.Xml;
 using System.Xml.Linq;
 using ErsatzTV.Core.Interfaces.Metadata.Nfo;
 
-namespace ErsatzTV.Core.Metadata.Nfo
+namespace ErsatzTV.Core.Metadata.Nfo;
+
+public class EpisodeNfoReader : IEpisodeNfoReader
 {
-    public class EpisodeNfoReader : IEpisodeNfoReader
+    public async Task<List<TvShowEpisodeNfo>> Read(Stream input)
     {
-        public async Task<List<TvShowEpisodeNfo>> Read(Stream input)
+        var result = new List<TvShowEpisodeNfo>();
+
+        var settings = new XmlReaderSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment };
+        using var reader = XmlReader.Create(input, settings);
+        TvShowEpisodeNfo nfo = null;
+
+        while (await reader.ReadAsync())
         {
-            var result = new List<TvShowEpisodeNfo>();
-
-            var settings = new XmlReaderSettings { Async = true, ConformanceLevel = ConformanceLevel.Fragment };
-            using var reader = XmlReader.Create(input, settings);
-            TvShowEpisodeNfo nfo = null;
-
-            while (await reader.ReadAsync())
+            switch (reader.NodeType)
             {
-                switch (reader.NodeType)
-                {
-                    case XmlNodeType.Element:
-                        switch (reader.Name.ToLowerInvariant())
-                        {
-                            case "episodedetails":
-                                nfo = new TvShowEpisodeNfo
-                                {
-                                    UniqueIds = new List<UniqueIdNfo>(),
-                                    Actors = new List<ActorNfo>(),
-                                    Writers = new List<string>(),
-                                    Directors = new List<string>()
-                                };
-                                break;
-                            case "title":
-                                await ReadTitle(reader, nfo);
-                                break;
-                            case "showtitle":
-                                await ReadShowTitle(reader, nfo);
-                                break;
-                            case "episode":
-                                await ReadEpisode(reader, nfo);
-                                break;
-                            case "season":
-                                await ReadSeason(reader, nfo);
-                                break;
-                            case "uniqueid":
-                                await ReadUniqueId(reader, nfo);
-                                break;
-                            case "mpaa":
-                                await ReadContentRating(reader, nfo);
-                                break;
-                            case "aired":
-                                // TODO: parse the date here
-                                await ReadAired(reader, nfo);
-                                break;
-                            case "plot":
-                                await ReadPlot(reader, nfo);
-                                break;
-                            case "actor":
-                                ReadActor(reader, nfo);
-                                break;
-                            case "credits":
-                                await ReadWriter(reader, nfo);
-                                break;
-                            case "director":
-                                await ReadDirector(reader, nfo);
-                                break;
-                        }
+                case XmlNodeType.Element:
+                    switch (reader.Name.ToLowerInvariant())
+                    {
+                        case "episodedetails":
+                            nfo = new TvShowEpisodeNfo
+                            {
+                                UniqueIds = new List<UniqueIdNfo>(),
+                                Actors = new List<ActorNfo>(),
+                                Writers = new List<string>(),
+                                Directors = new List<string>()
+                            };
+                            break;
+                        case "title":
+                            await ReadTitle(reader, nfo);
+                            break;
+                        case "showtitle":
+                            await ReadShowTitle(reader, nfo);
+                            break;
+                        case "episode":
+                            await ReadEpisode(reader, nfo);
+                            break;
+                        case "season":
+                            await ReadSeason(reader, nfo);
+                            break;
+                        case "uniqueid":
+                            await ReadUniqueId(reader, nfo);
+                            break;
+                        case "mpaa":
+                            await ReadContentRating(reader, nfo);
+                            break;
+                        case "aired":
+                            // TODO: parse the date here
+                            await ReadAired(reader, nfo);
+                            break;
+                        case "plot":
+                            await ReadPlot(reader, nfo);
+                            break;
+                        case "actor":
+                            ReadActor(reader, nfo);
+                            break;
+                        case "credits":
+                            await ReadWriter(reader, nfo);
+                            break;
+                        case "director":
+                            await ReadDirector(reader, nfo);
+                            break;
+                    }
 
-                        break;
-                    case XmlNodeType.EndElement:
-                        switch (reader.Name.ToLowerInvariant())
-                        {
-                            case "episodedetails":
-                                if (nfo != null)
-                                {
-                                    result.Add(nfo);
-                                }
+                    break;
+                case XmlNodeType.EndElement:
+                    switch (reader.Name.ToLowerInvariant())
+                    {
+                        case "episodedetails":
+                            if (nfo != null)
+                            {
+                                result.Add(nfo);
+                            }
 
-                                break;
-                        }
+                            break;
+                    }
 
-                        break;
-                }
-            }
-
-            return result;
-        }
-
-        private static async Task ReadTitle(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                nfo.Title = await reader.ReadElementContentAsStringAsync();
+                    break;
             }
         }
 
-        private static async Task ReadShowTitle(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                nfo.ShowTitle = await reader.ReadElementContentAsStringAsync();
-            }
-        }
-
-        private static async Task ReadEpisode(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                bool _ = int.TryParse(await reader.ReadElementContentAsStringAsync(), out int episode);
-                nfo.Episode = episode;
-            }
-        }
-
-        private static async Task ReadSeason(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                bool _ = int.TryParse(await reader.ReadElementContentAsStringAsync(), out int season);
-                nfo.Season = season;
-            }
-        }
-
-        private static async Task ReadUniqueId(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                var uniqueId = new UniqueIdNfo();
-                reader.MoveToAttribute("default");
-                uniqueId.Default = bool.TryParse(reader.Value, out bool def) && def;
-                reader.MoveToAttribute("type");
-                uniqueId.Type = reader.Value;
-                reader.MoveToElement();
-                uniqueId.Guid = await reader.ReadElementContentAsStringAsync();
-
-                nfo.UniqueIds.Add(uniqueId);
-            }
-        }
-
-        private static async Task ReadContentRating(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                nfo.ContentRating = await reader.ReadElementContentAsStringAsync();
-            }
-        }
-
-        private static async Task ReadAired(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                nfo.Aired = await reader.ReadElementContentAsStringAsync();
-            }
-        }
-
-        private static async Task ReadPlot(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                nfo.Plot = await reader.ReadElementContentAsStringAsync();
-            }
-        }
-
-        private static void ReadActor(XmlReader reader, TvShowEpisodeNfo nfo)
-        {
-            if (nfo != null)
-            {
-                var actor = new ActorNfo();
-                var element = (XElement) XNode.ReadFrom(reader);
-
-                XElement name = element.Element("name");
-                if (name != null)
-                {
-                    actor.Name = name.Value;
-                }
-
-                XElement role = element.Element("role");
-                if (role != null)
-                {
-                    actor.Role = role.Value;
-                }
-
-                XElement thumb = element.Element("thumb");
-                if (thumb != null)
-                {
-                    actor.Thumb = thumb.Value;
-                }
-
-                nfo.Actors.Add(actor);
-            }
-        }
-
-        private static async Task ReadWriter(XmlReader reader, TvShowEpisodeNfo nfo) =>
-            nfo?.Writers.Add(await reader.ReadElementContentAsStringAsync());
-
-        private static async Task ReadDirector(XmlReader reader, TvShowEpisodeNfo nfo) =>
-            nfo?.Directors.Add(await reader.ReadElementContentAsStringAsync());
+        return result;
     }
-}
+
+    private static async Task ReadTitle(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            nfo.Title = await reader.ReadElementContentAsStringAsync();
+        }
+    }
+
+    private static async Task ReadShowTitle(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            nfo.ShowTitle = await reader.ReadElementContentAsStringAsync();
+        }
+    }
+
+    private static async Task ReadEpisode(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            bool _ = int.TryParse(await reader.ReadElementContentAsStringAsync(), out int episode);
+            nfo.Episode = episode;
+        }
+    }
+
+    private static async Task ReadSeason(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            bool _ = int.TryParse(await reader.ReadElementContentAsStringAsync(), out int season);
+            nfo.Season = season;
+        }
+    }
+
+    private static async Task ReadUniqueId(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            var uniqueId = new UniqueIdNfo();
+            reader.MoveToAttribute("default");
+            uniqueId.Default = bool.TryParse(reader.Value, out bool def) && def;
+            reader.MoveToAttribute("type");
+            uniqueId.Type = reader.Value;
+            reader.MoveToElement();
+            uniqueId.Guid = await reader.ReadElementContentAsStringAsync();
+
+            nfo.UniqueIds.Add(uniqueId);
+        }
+    }
+
+    private static async Task ReadContentRating(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            nfo.ContentRating = await reader.ReadElementContentAsStringAsync();
+        }
+    }
+
+    private static async Task ReadAired(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            nfo.Aired = await reader.ReadElementContentAsStringAsync();
+        }
+    }
+
+    private static async Task ReadPlot(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            nfo.Plot = await reader.ReadElementContentAsStringAsync();
+        }
+    }
+
+    private static void ReadActor(XmlReader reader, TvShowEpisodeNfo nfo)
+    {
+        if (nfo != null)
+        {
+            var actor = new ActorNfo();
+            var element = (XElement) XNode.ReadFrom(reader);
+
+            XElement name = element.Element("name");
+            if (name != null)
+            {
+                actor.Name = name.Value;
+            }
+
+            XElement role = element.Element("role");
+            if (role != null)
+            {
+                actor.Role = role.Value;
+            }
+
+            XElement thumb = element.Element("thumb");
+            if (thumb != null)
+            {
+                actor.Thumb = thumb.Value;
+            }
+
+            nfo.Actors.Add(actor);
+        }
+    }
+
+    private static async Task ReadWriter(XmlReader reader, TvShowEpisodeNfo nfo) =>
+        nfo?.Writers.Add(await reader.ReadElementContentAsStringAsync());
+
+    private static async Task ReadDirector(XmlReader reader, TvShowEpisodeNfo nfo) =>
+        nfo?.Directors.Add(await reader.ReadElementContentAsStringAsync());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/Nfo/MovieNfo.cs b/ErsatzTV.Core/Metadata/Nfo/MovieNfo.cs
index 4bbcdf5b0..106f38ead 100644
--- a/ErsatzTV.Core/Metadata/Nfo/MovieNfo.cs
+++ b/ErsatzTV.Core/Metadata/Nfo/MovieNfo.cs
@@ -1,52 +1,49 @@
-using System;
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Core.Metadata.Nfo
+namespace ErsatzTV.Core.Metadata.Nfo;
+
+[XmlRoot("movie")]
+public class MovieNfo
 {
-    [XmlRoot("movie")]
-    public class MovieNfo
-    {
-        [XmlElement("title")]
-        public string Title { get; set; }
+    [XmlElement("title")]
+    public string Title { get; set; }
 
-        [XmlElement("outline")]
-        public string Outline { get; set; }
+    [XmlElement("outline")]
+    public string Outline { get; set; }
 
-        [XmlElement("year")]
-        public int Year { get; set; }
+    [XmlElement("year")]
+    public int Year { get; set; }
 
-        [XmlElement("mpaa")]
-        public string ContentRating { get; set; }
+    [XmlElement("mpaa")]
+    public string ContentRating { get; set; }
 
-        [XmlElement("premiered")]
-        public DateTime Premiered { get; set; }
+    [XmlElement("premiered")]
+    public DateTime Premiered { get; set; }
 
-        [XmlElement("plot")]
-        public string Plot { get; set; }
+    [XmlElement("plot")]
+    public string Plot { get; set; }
 
-        [XmlElement("tagline")]
-        public string Tagline { get; set; }
+    [XmlElement("tagline")]
+    public string Tagline { get; set; }
 
-        [XmlElement("genre")]
-        public List<string> Genres { get; set; }
+    [XmlElement("genre")]
+    public List<string> Genres { get; set; }
 
-        [XmlElement("tag")]
-        public List<string> Tags { get; set; }
+    [XmlElement("tag")]
+    public List<string> Tags { get; set; }
 
-        [XmlElement("studio")]
-        public List<string> Studios { get; set; }
+    [XmlElement("studio")]
+    public List<string> Studios { get; set; }
 
-        [XmlElement("actor")]
-        public List<ActorNfo> Actors { get; set; }
+    [XmlElement("actor")]
+    public List<ActorNfo> Actors { get; set; }
 
-        [XmlElement("credits")]
-        public List<string> Writers { get; set; }
+    [XmlElement("credits")]
+    public List<string> Writers { get; set; }
 
-        [XmlElement("director")]
-        public List<string> Directors { get; set; }
+    [XmlElement("director")]
+    public List<string> Directors { get; set; }
 
-        [XmlElement("uniqueid")]
-        public List<UniqueIdNfo> UniqueIds { get; set; }
-    }
-}
+    [XmlElement("uniqueid")]
+    public List<UniqueIdNfo> UniqueIds { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/Nfo/MusicVideoNfo.cs b/ErsatzTV.Core/Metadata/Nfo/MusicVideoNfo.cs
index f1786e187..35c7d9183 100644
--- a/ErsatzTV.Core/Metadata/Nfo/MusicVideoNfo.cs
+++ b/ErsatzTV.Core/Metadata/Nfo/MusicVideoNfo.cs
@@ -1,36 +1,34 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Core.Metadata.Nfo
+namespace ErsatzTV.Core.Metadata.Nfo;
+
+[XmlRoot("musicvideo")]
+public class MusicVideoNfo
 {
-    [XmlRoot("musicvideo")]
-    public class MusicVideoNfo
-    {
-        [XmlElement("artist")]
-        public string Artist { get; set; }
+    [XmlElement("artist")]
+    public string Artist { get; set; }
 
-        [XmlElement("title")]
-        public string Title { get; set; }
+    [XmlElement("title")]
+    public string Title { get; set; }
 
-        [XmlElement("album")]
-        public string Album { get; set; }
+    [XmlElement("album")]
+    public string Album { get; set; }
 
-        [XmlElement("plot")]
-        public string Plot { get; set; }
+    [XmlElement("plot")]
+    public string Plot { get; set; }
 
-        [XmlElement("premiered")]
-        public string Premiered { get; set; }
+    [XmlElement("premiered")]
+    public string Premiered { get; set; }
 
-        [XmlElement("year")]
-        public int Year { get; set; }
+    [XmlElement("year")]
+    public int Year { get; set; }
 
-        [XmlElement("genre")]
-        public List<string> Genres { get; set; }
+    [XmlElement("genre")]
+    public List<string> Genres { get; set; }
 
-        [XmlElement("tag")]
-        public List<string> Tags { get; set; }
+    [XmlElement("tag")]
+    public List<string> Tags { get; set; }
 
-        [XmlElement("studio")]
-        public List<string> Studios { get; set; }
-    }
-}
+    [XmlElement("studio")]
+    public List<string> Studios { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/Nfo/TvShowEpisodeNfo.cs b/ErsatzTV.Core/Metadata/Nfo/TvShowEpisodeNfo.cs
index 0009346c2..915283dc0 100644
--- a/ErsatzTV.Core/Metadata/Nfo/TvShowEpisodeNfo.cs
+++ b/ErsatzTV.Core/Metadata/Nfo/TvShowEpisodeNfo.cs
@@ -1,42 +1,40 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Core.Metadata.Nfo
+namespace ErsatzTV.Core.Metadata.Nfo;
+
+[XmlRoot("episodedetails")]
+public class TvShowEpisodeNfo
 {
-    [XmlRoot("episodedetails")]
-    public class TvShowEpisodeNfo
-    {
-        [XmlElement("showtitle")]
-        public string ShowTitle { get; set; }
+    [XmlElement("showtitle")]
+    public string ShowTitle { get; set; }
 
-        [XmlElement("title")]
-        public string Title { get; set; }
+    [XmlElement("title")]
+    public string Title { get; set; }
 
-        [XmlElement("episode")]
-        public int Episode { get; set; }
+    [XmlElement("episode")]
+    public int Episode { get; set; }
 
-        [XmlElement("season")]
-        public int Season { get; set; }
+    [XmlElement("season")]
+    public int Season { get; set; }
 
-        [XmlElement("mpaa")]
-        public string ContentRating { get; set; }
+    [XmlElement("mpaa")]
+    public string ContentRating { get; set; }
 
-        [XmlElement("aired")]
-        public string Aired { get; set; }
+    [XmlElement("aired")]
+    public string Aired { get; set; }
 
-        [XmlElement("plot")]
-        public string Plot { get; set; }
+    [XmlElement("plot")]
+    public string Plot { get; set; }
 
-        [XmlElement("actor")]
-        public List<ActorNfo> Actors { get; set; }
+    [XmlElement("actor")]
+    public List<ActorNfo> Actors { get; set; }
 
-        [XmlElement("credits")]
-        public List<string> Writers { get; set; }
+    [XmlElement("credits")]
+    public List<string> Writers { get; set; }
 
-        [XmlElement("director")]
-        public List<string> Directors { get; set; }
+    [XmlElement("director")]
+    public List<string> Directors { get; set; }
 
-        [XmlElement("uniqueid")]
-        public List<UniqueIdNfo> UniqueIds { get; set; }
-    }
-}
+    [XmlElement("uniqueid")]
+    public List<UniqueIdNfo> UniqueIds { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/Nfo/TvShowNfo.cs b/ErsatzTV.Core/Metadata/Nfo/TvShowNfo.cs
index 835338a55..be26595c1 100644
--- a/ErsatzTV.Core/Metadata/Nfo/TvShowNfo.cs
+++ b/ErsatzTV.Core/Metadata/Nfo/TvShowNfo.cs
@@ -1,52 +1,50 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Core.Metadata.Nfo
+namespace ErsatzTV.Core.Metadata.Nfo;
+
+[XmlRoot("tvshow")]
+public class TvShowNfo
 {
-    [XmlRoot("tvshow")]
-    public class TvShowNfo
+    [XmlElement("title")]
+    public string Title { get; set; }
+
+    [XmlIgnore]
+    public int? Year { get; set; }
+
+    [XmlElement("year")]
+    public string YearAsText
     {
-        [XmlElement("title")]
-        public string Title { get; set; }
-
-        [XmlIgnore]
-        public int? Year { get; set; }
-
-        [XmlElement("year")]
-        public string YearAsText
-        {
-            get => Year.HasValue ? Year.ToString() : null;
-            set => Year = !string.IsNullOrWhiteSpace(value) ? int.Parse(value) : default(int?);
-        }
-
-        [XmlElement("plot")]
-        public string Plot { get; set; }
-
-        [XmlElement("outline")]
-        public string Outline { get; set; }
-
-        [XmlElement("tagline")]
-        public string Tagline { get; set; }
-
-        [XmlElement("mpaa")]
-        public string ContentRating { get; set; }
-
-        [XmlElement("premiered")]
-        public string Premiered { get; set; }
-
-        [XmlElement("genre")]
-        public List<string> Genres { get; set; }
-
-        [XmlElement("tag")]
-        public List<string> Tags { get; set; }
-
-        [XmlElement("studio")]
-        public List<string> Studios { get; set; }
-
-        [XmlElement("actor")]
-        public List<ActorNfo> Actors { get; set; }
-
-        [XmlElement("uniqueid")]
-        public List<UniqueIdNfo> UniqueIds { get; set; }
+        get => Year.HasValue ? Year.ToString() : null;
+        set => Year = !string.IsNullOrWhiteSpace(value) ? int.Parse(value) : default(int?);
     }
-}
+
+    [XmlElement("plot")]
+    public string Plot { get; set; }
+
+    [XmlElement("outline")]
+    public string Outline { get; set; }
+
+    [XmlElement("tagline")]
+    public string Tagline { get; set; }
+
+    [XmlElement("mpaa")]
+    public string ContentRating { get; set; }
+
+    [XmlElement("premiered")]
+    public string Premiered { get; set; }
+
+    [XmlElement("genre")]
+    public List<string> Genres { get; set; }
+
+    [XmlElement("tag")]
+    public List<string> Tags { get; set; }
+
+    [XmlElement("studio")]
+    public List<string> Studios { get; set; }
+
+    [XmlElement("actor")]
+    public List<ActorNfo> Actors { get; set; }
+
+    [XmlElement("uniqueid")]
+    public List<UniqueIdNfo> UniqueIds { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/Nfo/UniqueIdNfo.cs b/ErsatzTV.Core/Metadata/Nfo/UniqueIdNfo.cs
index 04ec995da..9b24c9bcc 100644
--- a/ErsatzTV.Core/Metadata/Nfo/UniqueIdNfo.cs
+++ b/ErsatzTV.Core/Metadata/Nfo/UniqueIdNfo.cs
@@ -1,16 +1,15 @@
 using System.Xml.Serialization;
 
-namespace ErsatzTV.Core.Metadata.Nfo
+namespace ErsatzTV.Core.Metadata.Nfo;
+
+public class UniqueIdNfo
 {
-    public class UniqueIdNfo
-    {
-        [XmlAttribute("default")]
-        public bool Default { get; set; }
+    [XmlAttribute("default")]
+    public bool Default { get; set; }
 
-        [XmlAttribute("type")]
-        public string Type { get; set; }
+    [XmlAttribute("type")]
+    public string Type { get; set; }
 
-        [XmlText]
-        public string Guid { get; set; }
-    }
-}
+    [XmlText]
+    public string Guid { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/OtherVideoFolderScanner.cs b/ErsatzTV.Core/Metadata/OtherVideoFolderScanner.cs
index eb2d42a8d..99be8eb19 100644
--- a/ErsatzTV.Core/Metadata/OtherVideoFolderScanner.cs
+++ b/ErsatzTV.Core/Metadata/OtherVideoFolderScanner.cs
@@ -1,206 +1,197 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class OtherVideoFolderScanner : LocalFolderScanner, IOtherVideoFolderScanner
 {
-    public class OtherVideoFolderScanner : LocalFolderScanner, IOtherVideoFolderScanner
-    {
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalMetadataProvider _localMetadataProvider;
-        private readonly IMediator _mediator;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
-        private readonly IOtherVideoRepository _otherVideoRepository;
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILogger<OtherVideoFolderScanner> _logger;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalMetadataProvider _localMetadataProvider;
+    private readonly IMediator _mediator;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+    private readonly IOtherVideoRepository _otherVideoRepository;
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILogger<OtherVideoFolderScanner> _logger;
 
-        public OtherVideoFolderScanner(
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILocalMetadataProvider localMetadataProvider,
-            IMetadataRepository metadataRepository,
-            IImageCache imageCache,
-            IMediator mediator,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            IOtherVideoRepository otherVideoRepository,
-            ILibraryRepository libraryRepository,
-            IMediaItemRepository mediaItemRepository,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
-            ITempFilePool tempFilePool,
-            ILogger<OtherVideoFolderScanner> logger) : base(
-            localFileSystem,
-            localStatisticsProvider,
-            metadataRepository,
-            mediaItemRepository,
-            imageCache,
-            ffmpegProcessServiceFactory,
-            tempFilePool,
-            logger)
+    public OtherVideoFolderScanner(
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILocalMetadataProvider localMetadataProvider,
+        IMetadataRepository metadataRepository,
+        IImageCache imageCache,
+        IMediator mediator,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        IOtherVideoRepository otherVideoRepository,
+        ILibraryRepository libraryRepository,
+        IMediaItemRepository mediaItemRepository,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
+        ITempFilePool tempFilePool,
+        ILogger<OtherVideoFolderScanner> logger) : base(
+        localFileSystem,
+        localStatisticsProvider,
+        metadataRepository,
+        mediaItemRepository,
+        imageCache,
+        ffmpegProcessServiceFactory,
+        tempFilePool,
+        logger)
+    {
+        _localFileSystem = localFileSystem;
+        _localMetadataProvider = localMetadataProvider;
+        _mediator = mediator;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _otherVideoRepository = otherVideoRepository;
+        _libraryRepository = libraryRepository;
+        _logger = logger;
+    }
+
+    public async Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        decimal progressMin,
+        decimal progressMax)
+    {
+        decimal progressSpread = progressMax - progressMin;
+
+        var foldersCompleted = 0;
+
+        var folderQueue = new Queue<string>();
+
+        if (ShouldIncludeFolder(libraryPath.Path))
         {
-            _localFileSystem = localFileSystem;
-            _localMetadataProvider = localMetadataProvider;
-            _mediator = mediator;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _otherVideoRepository = otherVideoRepository;
-            _libraryRepository = libraryRepository;
-            _logger = logger;
+            folderQueue.Enqueue(libraryPath.Path);
         }
 
-        public async Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            decimal progressMin,
-            decimal progressMax)
+        foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path)
+                     .Filter(ShouldIncludeFolder)
+                     .OrderBy(identity))
         {
-            decimal progressSpread = progressMax - progressMin;
+            folderQueue.Enqueue(folder);
+        }
 
-            var foldersCompleted = 0;
+        while (folderQueue.Count > 0)
+        {
+            decimal percentCompletion = (decimal)foldersCompleted / (foldersCompleted + folderQueue.Count);
+            await _mediator.Publish(
+                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
 
-            var folderQueue = new Queue<string>();
+            string otherVideoFolder = folderQueue.Dequeue();
+            foldersCompleted++;
 
-            if (ShouldIncludeFolder(libraryPath.Path))
-            {
-                folderQueue.Enqueue(libraryPath.Path);
-            }
+            var filesForEtag = _localFileSystem.ListFiles(otherVideoFolder).ToList();
 
-            foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path)
+            var allFiles = filesForEtag
+                .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
+                .Filter(f => !Path.GetFileName(f).StartsWith("._"))
+                .ToList();
+
+            foreach (string subdirectory in _localFileSystem.ListSubdirectories(otherVideoFolder)
                          .Filter(ShouldIncludeFolder)
                          .OrderBy(identity))
             {
-                folderQueue.Enqueue(folder);
+                folderQueue.Enqueue(subdirectory);
             }
 
-            while (folderQueue.Count > 0)
+            string etag = FolderEtag.Calculate(otherVideoFolder, _localFileSystem);
+            Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
+                .Filter(f => f.Path == otherVideoFolder)
+                .HeadOrNone();
+
+            // skip folder if etag matches
+            if (!allFiles.Any() || await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
             {
-                decimal percentCompletion = (decimal)foldersCompleted / (foldersCompleted + folderQueue.Count);
-                await _mediator.Publish(
-                    new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
-
-                string otherVideoFolder = folderQueue.Dequeue();
-                foldersCompleted++;
-
-                var filesForEtag = _localFileSystem.ListFiles(otherVideoFolder).ToList();
-
-                var allFiles = filesForEtag
-                    .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
-                    .Filter(f => !Path.GetFileName(f).StartsWith("._"))
-                    .ToList();
-
-                foreach (string subdirectory in _localFileSystem.ListSubdirectories(otherVideoFolder)
-                    .Filter(ShouldIncludeFolder)
-                    .OrderBy(identity))
-                {
-                    folderQueue.Enqueue(subdirectory);
-                }
-
-                string etag = FolderEtag.Calculate(otherVideoFolder, _localFileSystem);
-                Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
-                    .Filter(f => f.Path == otherVideoFolder)
-                    .HeadOrNone();
-
-                // skip folder if etag matches
-                if (!allFiles.Any() || await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
-                {
-                    continue;
-                }
-
-                _logger.LogDebug(
-                    "UPDATE: Etag has changed for folder {Folder}",
-                    otherVideoFolder);
-
-                foreach (string file in allFiles.OrderBy(identity))
-                {
-                    Either<BaseError, MediaItemScanResult<OtherVideo>> maybeVideo = await _otherVideoRepository
-                        .GetOrAdd(libraryPath, file)
-                        .BindT(video => UpdateStatistics(video, ffprobePath))
-                        .BindT(UpdateMetadata)
-                        .BindT(FlagNormal);
-
-                    await maybeVideo.Match(
-                        async result =>
-                        {
-                            if (result.IsAdded)
-                            {
-                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
-                            }
-                            else if (result.IsUpdated)
-                            {
-                                await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
-                            }
-
-                            await _libraryRepository.SetEtag(libraryPath, knownFolder, otherVideoFolder, etag);
-                        },
-                        error =>
-                        {
-                            _logger.LogWarning("Error processing other video at {Path}: {Error}", file, error.Value);
-                            return Task.CompletedTask;
-                        });
-                }
+                continue;
             }
 
-            foreach (string path in await _otherVideoRepository.FindOtherVideoPaths(libraryPath))
+            _logger.LogDebug(
+                "UPDATE: Etag has changed for folder {Folder}",
+                otherVideoFolder);
+
+            foreach (string file in allFiles.OrderBy(identity))
             {
-                if (!_localFileSystem.FileExists(path))
-                {
-                    _logger.LogInformation("Flagging missing other video at {Path}", path);
-                    List<int> otherVideoIds = await FlagFileNotFound(libraryPath, path);
-                    await _searchIndex.RebuildItems(_searchRepository, otherVideoIds);
-                }
-                else if (Path.GetFileName(path).StartsWith("._"))
-                {
-                    _logger.LogInformation("Removing dot underscore file at {Path}", path);
-                    List<int> otherVideoIds = await _otherVideoRepository.DeleteByPath(libraryPath, path);
-                    await _searchIndex.RemoveItems(otherVideoIds);
-                }
-            }
-            
-            await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
+                Either<BaseError, MediaItemScanResult<OtherVideo>> maybeVideo = await _otherVideoRepository
+                    .GetOrAdd(libraryPath, file)
+                    .BindT(video => UpdateStatistics(video, ffprobePath))
+                    .BindT(UpdateMetadata)
+                    .BindT(FlagNormal);
 
-            _searchIndex.Commit();
-            return Unit.Default;
+                await maybeVideo.Match(
+                    async result =>
+                    {
+                        if (result.IsAdded)
+                        {
+                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                        }
+                        else if (result.IsUpdated)
+                        {
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
+                        }
+
+                        await _libraryRepository.SetEtag(libraryPath, knownFolder, otherVideoFolder, etag);
+                    },
+                    error =>
+                    {
+                        _logger.LogWarning("Error processing other video at {Path}: {Error}", file, error.Value);
+                        return Task.CompletedTask;
+                    });
+            }
         }
 
-        private async Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> UpdateMetadata(
-            MediaItemScanResult<OtherVideo> result)
+        foreach (string path in await _otherVideoRepository.FindOtherVideoPaths(libraryPath))
         {
-            try
+            if (!_localFileSystem.FileExists(path))
             {
-                OtherVideo otherVideo = result.Item;
-                if (!Optional(otherVideo.OtherVideoMetadata).Flatten().Any())
+                _logger.LogInformation("Flagging missing other video at {Path}", path);
+                List<int> otherVideoIds = await FlagFileNotFound(libraryPath, path);
+                await _searchIndex.RebuildItems(_searchRepository, otherVideoIds);
+            }
+            else if (Path.GetFileName(path).StartsWith("._"))
+            {
+                _logger.LogInformation("Removing dot underscore file at {Path}", path);
+                List<int> otherVideoIds = await _otherVideoRepository.DeleteByPath(libraryPath, path);
+                await _searchIndex.RemoveItems(otherVideoIds);
+            }
+        }
+            
+        await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
+
+        _searchIndex.Commit();
+        return Unit.Default;
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> UpdateMetadata(
+        MediaItemScanResult<OtherVideo> result)
+    {
+        try
+        {
+            OtherVideo otherVideo = result.Item;
+            if (!Optional(otherVideo.OtherVideoMetadata).Flatten().Any())
+            {
+                otherVideo.OtherVideoMetadata ??= new List<OtherVideoMetadata>();
+
+                string path = otherVideo.MediaVersions.Head().MediaFiles.Head().Path;
+                _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
+                if (await _localMetadataProvider.RefreshFallbackMetadata(otherVideo))
                 {
-                    otherVideo.OtherVideoMetadata ??= new List<OtherVideoMetadata>();
-
-                    string path = otherVideo.MediaVersions.Head().MediaFiles.Head().Path;
-                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
-                    if (await _localMetadataProvider.RefreshFallbackMetadata(otherVideo))
-                    {
-                        result.IsUpdated = true;
-                    }
+                    result.IsUpdated = true;
                 }
+            }
 
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/SongFolderScanner.cs b/ErsatzTV.Core/Metadata/SongFolderScanner.cs
index 3f2404580..b616ea713 100644
--- a/ErsatzTV.Core/Metadata/SongFolderScanner.cs
+++ b/ErsatzTV.Core/Metadata/SongFolderScanner.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
@@ -11,271 +6,267 @@ using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class SongFolderScanner : LocalFolderScanner, ISongFolderScanner
 {
-    public class SongFolderScanner : LocalFolderScanner, ISongFolderScanner
-    {
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalMetadataProvider _localMetadataProvider;
-        private readonly IMediator _mediator;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
-        private readonly ISongRepository _songRepository;
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILogger<SongFolderScanner> _logger;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalMetadataProvider _localMetadataProvider;
+    private readonly IMediator _mediator;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+    private readonly ISongRepository _songRepository;
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILogger<SongFolderScanner> _logger;
 
-        public SongFolderScanner(
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILocalMetadataProvider localMetadataProvider,
-            IMetadataRepository metadataRepository,
-            IImageCache imageCache,
-            IMediator mediator,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            ISongRepository songRepository,
-            ILibraryRepository libraryRepository,
-            IMediaItemRepository mediaItemRepository,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
-            ITempFilePool tempFilePool,
-            ILogger<SongFolderScanner> logger) : base(
-            localFileSystem,
-            localStatisticsProvider,
-            metadataRepository,
-            mediaItemRepository,
-            imageCache,
-            ffmpegProcessServiceFactory,
-            tempFilePool,
-            logger)
+    public SongFolderScanner(
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILocalMetadataProvider localMetadataProvider,
+        IMetadataRepository metadataRepository,
+        IImageCache imageCache,
+        IMediator mediator,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        ISongRepository songRepository,
+        ILibraryRepository libraryRepository,
+        IMediaItemRepository mediaItemRepository,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
+        ITempFilePool tempFilePool,
+        ILogger<SongFolderScanner> logger) : base(
+        localFileSystem,
+        localStatisticsProvider,
+        metadataRepository,
+        mediaItemRepository,
+        imageCache,
+        ffmpegProcessServiceFactory,
+        tempFilePool,
+        logger)
+    {
+        _localFileSystem = localFileSystem;
+        _localMetadataProvider = localMetadataProvider;
+        _mediator = mediator;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _songRepository = songRepository;
+        _libraryRepository = libraryRepository;
+        _logger = logger;
+    }
+
+    public async Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        string ffmpegPath,
+        decimal progressMin,
+        decimal progressMax)
+    {
+        decimal progressSpread = progressMax - progressMin;
+
+        var foldersCompleted = 0;
+
+        var folderQueue = new Queue<string>();
+            
+        if (ShouldIncludeFolder(libraryPath.Path))
         {
-            _localFileSystem = localFileSystem;
-            _localMetadataProvider = localMetadataProvider;
-            _mediator = mediator;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _songRepository = songRepository;
-            _libraryRepository = libraryRepository;
-            _logger = logger;
+            folderQueue.Enqueue(libraryPath.Path);
         }
 
-        public async Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            string ffmpegPath,
-            decimal progressMin,
-            decimal progressMax)
+        foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path)
+                     .Filter(ShouldIncludeFolder)
+                     .OrderBy(identity))
         {
-            decimal progressSpread = progressMax - progressMin;
+            folderQueue.Enqueue(folder);
+        }
 
-            var foldersCompleted = 0;
+        while (folderQueue.Count > 0)
+        {
+            decimal percentCompletion = (decimal)foldersCompleted / (foldersCompleted + folderQueue.Count);
+            await _mediator.Publish(
+                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
 
-            var folderQueue = new Queue<string>();
-            
-            if (ShouldIncludeFolder(libraryPath.Path))
-            {
-                folderQueue.Enqueue(libraryPath.Path);
-            }
+            string songFolder = folderQueue.Dequeue();
+            foldersCompleted++;
 
-            foreach (string folder in _localFileSystem.ListSubdirectories(libraryPath.Path)
+            var filesForEtag = _localFileSystem.ListFiles(songFolder).ToList();
+
+            var allFiles = filesForEtag
+                .Filter(f => AudioFileExtensions.Contains(Path.GetExtension(f)))
+                .Filter(f => !Path.GetFileName(f).StartsWith("._"))
+                .ToList();
+
+            foreach (string subdirectory in _localFileSystem.ListSubdirectories(songFolder)
                          .Filter(ShouldIncludeFolder)
                          .OrderBy(identity))
             {
-                folderQueue.Enqueue(folder);
+                folderQueue.Enqueue(subdirectory);
             }
 
-            while (folderQueue.Count > 0)
+            string etag = FolderEtag.Calculate(songFolder, _localFileSystem);
+            Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
+                .Filter(f => f.Path == songFolder)
+                .HeadOrNone();
+
+            // skip folder if etag matches
+            if (!allFiles.Any() || await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
             {
-                decimal percentCompletion = (decimal)foldersCompleted / (foldersCompleted + folderQueue.Count);
-                await _mediator.Publish(
-                    new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
+                continue;
+            }
 
-                string songFolder = folderQueue.Dequeue();
-                foldersCompleted++;
+            _logger.LogDebug(
+                "UPDATE: Etag has changed for folder {Folder}",
+                songFolder);
 
-                var filesForEtag = _localFileSystem.ListFiles(songFolder).ToList();
+            foreach (string file in allFiles.OrderBy(identity))
+            {
+                Either<BaseError, MediaItemScanResult<Song>> maybeSong = await _songRepository
+                    .GetOrAdd(libraryPath, file)
+                    .BindT(video => UpdateStatistics(video, ffprobePath))
+                    .BindT(video => UpdateMetadata(video, ffprobePath))
+                    .BindT(video => UpdateThumbnail(video, ffmpegPath))
+                    .BindT(FlagNormal);
 
-                var allFiles = filesForEtag
-                    .Filter(f => AudioFileExtensions.Contains(Path.GetExtension(f)))
-                    .Filter(f => !Path.GetFileName(f).StartsWith("._"))
-                    .ToList();
-
-                foreach (string subdirectory in _localFileSystem.ListSubdirectories(songFolder)
-                    .Filter(ShouldIncludeFolder)
-                    .OrderBy(identity))
-                {
-                    folderQueue.Enqueue(subdirectory);
-                }
-
-                string etag = FolderEtag.Calculate(songFolder, _localFileSystem);
-                Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
-                    .Filter(f => f.Path == songFolder)
-                    .HeadOrNone();
-
-                // skip folder if etag matches
-                if (!allFiles.Any() || await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
-                {
-                    continue;
-                }
-
-                _logger.LogDebug(
-                    "UPDATE: Etag has changed for folder {Folder}",
-                    songFolder);
-
-                foreach (string file in allFiles.OrderBy(identity))
-                {
-                    Either<BaseError, MediaItemScanResult<Song>> maybeSong = await _songRepository
-                        .GetOrAdd(libraryPath, file)
-                        .BindT(video => UpdateStatistics(video, ffprobePath))
-                        .BindT(video => UpdateMetadata(video, ffprobePath))
-                        .BindT(video => UpdateThumbnail(video, ffmpegPath))
-                        .BindT(FlagNormal);
-
-                    await maybeSong.Match(
-                        async result =>
+                await maybeSong.Match(
+                    async result =>
+                    {
+                        if (result.IsAdded)
                         {
-                            if (result.IsAdded)
-                            {
-                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
-                            }
-                            else if (result.IsUpdated)
-                            {
-                                await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
-                            }
-
-                            await _libraryRepository.SetEtag(libraryPath, knownFolder, songFolder, etag);
-                        },
-                        error =>
+                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                        }
+                        else if (result.IsUpdated)
                         {
-                            _logger.LogWarning("Error processing song at {Path}: {Error}", file, error.Value);
-                            return Task.CompletedTask;
-                        });
-                }
-            }
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
+                        }
 
-            foreach (string path in await _songRepository.FindSongPaths(libraryPath))
-            {
-                if (!_localFileSystem.FileExists(path))
-                {
-                    _logger.LogInformation("Flagging missing song at {Path}", path);
-                    List<int> songIds = await FlagFileNotFound(libraryPath, path);
-                    await _searchIndex.RebuildItems(_searchRepository, songIds);
-                }
-                else if (Path.GetFileName(path).StartsWith("._"))
-                {
-                    _logger.LogInformation("Removing dot underscore file at {Path}", path);
-                    List<int> songIds = await _songRepository.DeleteByPath(libraryPath, path);
-                    await _searchIndex.RemoveItems(songIds);
-                }
-            }
-            
-            await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
-
-            _searchIndex.Commit();
-            return Unit.Default;
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Song>>> UpdateMetadata(
-            MediaItemScanResult<Song> result, string ffprobePath)
-        {
-            try
-            {
-                Song song = result.Item;
-                string path = song.GetHeadVersion().MediaFiles.Head().Path;
-                
-                bool shouldUpdate = Optional(song.SongMetadata).Flatten().HeadOrNone().Match(
-                    m => m.MetadataKind == MetadataKind.Fallback ||
-                         m.DateUpdated != _localFileSystem.GetLastWriteTime(path),
-                    true);
-
-                if (shouldUpdate)
-                {
-                    song.SongMetadata ??= new List<SongMetadata>();
-
-                    _logger.LogDebug("Refreshing {Attribute} for {Path}", "Metadata", path);
-                    if (await _localMetadataProvider.RefreshTagMetadata(song, ffprobePath))
-                    {
-                        result.IsUpdated = true;
-                    }
-                }
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Song>>> UpdateThumbnail(
-            MediaItemScanResult<Song> result,
-            string ffmpegPath)
-        {
-            try
-            {
-                // reload the song from the database at this point
-                if (result.IsAdded)
-                {
-                    LibraryPath libraryPath = result.Item.LibraryPath;
-                    string path = result.Item.GetHeadVersion().MediaFiles.Head().Path;
-                    foreach (MediaItemScanResult<Song> s in (await _songRepository.GetOrAdd(libraryPath, path))
-                        .RightToSeq())
-                    {
-                        result.Item = s.Item;
-                    }
-                }
-
-                Song song = result.Item;
-
-                await LocateThumbnail(song).Match(
-                    async thumbnailFile =>
-                    {
-                        SongMetadata metadata = song.SongMetadata.Head();
-                        await RefreshArtwork(thumbnailFile, metadata, ArtworkKind.Thumbnail, ffmpegPath, None);
+                        await _libraryRepository.SetEtag(libraryPath, knownFolder, songFolder, etag);
                     },
-                    () => ExtractEmbeddedArtwork(song, ffmpegPath));
-        
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
+                    error =>
+                    {
+                        _logger.LogWarning("Error processing song at {Path}: {Error}", file, error.Value);
+                        return Task.CompletedTask;
+                    });
             }
         }
-        
-        private Option<string> LocateThumbnail(Song song)
-        {
-            string path = song.MediaVersions.Head().MediaFiles.Head().Path;
-            Option<DirectoryInfo> parent = Optional(Directory.GetParent(path));
 
-            return parent.Map(
-                di =>
+        foreach (string path in await _songRepository.FindSongPaths(libraryPath))
+        {
+            if (!_localFileSystem.FileExists(path))
+            {
+                _logger.LogInformation("Flagging missing song at {Path}", path);
+                List<int> songIds = await FlagFileNotFound(libraryPath, path);
+                await _searchIndex.RebuildItems(_searchRepository, songIds);
+            }
+            else if (Path.GetFileName(path).StartsWith("._"))
+            {
+                _logger.LogInformation("Removing dot underscore file at {Path}", path);
+                List<int> songIds = await _songRepository.DeleteByPath(libraryPath, path);
+                await _searchIndex.RemoveItems(songIds);
+            }
+        }
+            
+        await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
+
+        _searchIndex.Commit();
+        return Unit.Default;
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<Song>>> UpdateMetadata(
+        MediaItemScanResult<Song> result, string ffprobePath)
+    {
+        try
+        {
+            Song song = result.Item;
+            string path = song.GetHeadVersion().MediaFiles.Head().Path;
+                
+            bool shouldUpdate = Optional(song.SongMetadata).Flatten().HeadOrNone().Match(
+                m => m.MetadataKind == MetadataKind.Fallback ||
+                     m.DateUpdated != _localFileSystem.GetLastWriteTime(path),
+                true);
+
+            if (shouldUpdate)
+            {
+                song.SongMetadata ??= new List<SongMetadata>();
+
+                _logger.LogDebug("Refreshing {Attribute} for {Path}", "Metadata", path);
+                if (await _localMetadataProvider.RefreshTagMetadata(song, ffprobePath))
                 {
-                    string coverPath = Path.Combine(di.FullName, "cover.jpg");
-                    return ImageFileExtensions
-                        .Map(ext => Path.ChangeExtension(coverPath, ext))
-                        .Filter(f => _localFileSystem.FileExists(f))
-                        .HeadOrNone();
-                }).Flatten();
-        }
-
-        private async Task ExtractEmbeddedArtwork(Song song, string ffmpegPath)
-        {
-            Option<MediaStream> maybeArtworkStream = Optional(song.GetHeadVersion().Streams.Find(ms => ms.AttachedPic));
-            foreach (MediaStream artworkStream in maybeArtworkStream)
-            {
-                await RefreshArtwork(
-                    song.GetHeadVersion().MediaFiles.Head().Path,
-                    song.SongMetadata.Head(),
-                    ArtworkKind.Thumbnail,
-                    ffmpegPath,
-                    artworkStream.Index);
+                    result.IsUpdated = true;
+                }
             }
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
         }
     }
-}
+
+    private async Task<Either<BaseError, MediaItemScanResult<Song>>> UpdateThumbnail(
+        MediaItemScanResult<Song> result,
+        string ffmpegPath)
+    {
+        try
+        {
+            // reload the song from the database at this point
+            if (result.IsAdded)
+            {
+                LibraryPath libraryPath = result.Item.LibraryPath;
+                string path = result.Item.GetHeadVersion().MediaFiles.Head().Path;
+                foreach (MediaItemScanResult<Song> s in (await _songRepository.GetOrAdd(libraryPath, path))
+                         .RightToSeq())
+                {
+                    result.Item = s.Item;
+                }
+            }
+
+            Song song = result.Item;
+
+            await LocateThumbnail(song).Match(
+                async thumbnailFile =>
+                {
+                    SongMetadata metadata = song.SongMetadata.Head();
+                    await RefreshArtwork(thumbnailFile, metadata, ArtworkKind.Thumbnail, ffmpegPath, None);
+                },
+                () => ExtractEmbeddedArtwork(song, ffmpegPath));
+        
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+        
+    private Option<string> LocateThumbnail(Song song)
+    {
+        string path = song.MediaVersions.Head().MediaFiles.Head().Path;
+        Option<DirectoryInfo> parent = Optional(Directory.GetParent(path));
+
+        return parent.Map(
+            di =>
+            {
+                string coverPath = Path.Combine(di.FullName, "cover.jpg");
+                return ImageFileExtensions
+                    .Map(ext => Path.ChangeExtension(coverPath, ext))
+                    .Filter(f => _localFileSystem.FileExists(f))
+                    .HeadOrNone();
+            }).Flatten();
+    }
+
+    private async Task ExtractEmbeddedArtwork(Song song, string ffmpegPath)
+    {
+        Option<MediaStream> maybeArtworkStream = Optional(song.GetHeadVersion().Streams.Find(ms => ms.AttachedPic));
+        foreach (MediaStream artworkStream in maybeArtworkStream)
+        {
+            await RefreshArtwork(
+                song.GetHeadVersion().MediaFiles.Head().Path,
+                song.SongMetadata.Head(),
+                ArtworkKind.Thumbnail,
+                ffmpegPath,
+                artworkStream.Index);
+        }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs b/ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs
index 0604a87af..8d1464b36 100644
--- a/ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs
+++ b/ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs
@@ -1,487 +1,478 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Metadata
+namespace ErsatzTV.Core.Metadata;
+
+public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScanner
 {
-    public class TelevisionFolderScanner : LocalFolderScanner, ITelevisionFolderScanner
+    private readonly ILibraryRepository _libraryRepository;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalMetadataProvider _localMetadataProvider;
+    private readonly ILogger<TelevisionFolderScanner> _logger;
+    private readonly IMediator _mediator;
+    private readonly IMetadataRepository _metadataRepository;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public TelevisionFolderScanner(
+        ILocalFileSystem localFileSystem,
+        ITelevisionRepository televisionRepository,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILocalMetadataProvider localMetadataProvider,
+        IMetadataRepository metadataRepository,
+        IImageCache imageCache,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        ILibraryRepository libraryRepository,
+        IMediaItemRepository mediaItemRepository,
+        IMediator mediator,
+        IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
+        ITempFilePool tempFilePool,
+        ILogger<TelevisionFolderScanner> logger) : base(
+        localFileSystem,
+        localStatisticsProvider,
+        metadataRepository,
+        mediaItemRepository,
+        imageCache,
+        ffmpegProcessServiceFactory,
+        tempFilePool,
+        logger)
     {
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalMetadataProvider _localMetadataProvider;
-        private readonly ILogger<TelevisionFolderScanner> _logger;
-        private readonly IMediator _mediator;
-        private readonly IMetadataRepository _metadataRepository;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
-        private readonly ITelevisionRepository _televisionRepository;
+        _localFileSystem = localFileSystem;
+        _televisionRepository = televisionRepository;
+        _localMetadataProvider = localMetadataProvider;
+        _metadataRepository = metadataRepository;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _libraryRepository = libraryRepository;
+        _mediator = mediator;
+        _logger = logger;
+    }
 
-        public TelevisionFolderScanner(
-            ILocalFileSystem localFileSystem,
-            ITelevisionRepository televisionRepository,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILocalMetadataProvider localMetadataProvider,
-            IMetadataRepository metadataRepository,
-            IImageCache imageCache,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            ILibraryRepository libraryRepository,
-            IMediaItemRepository mediaItemRepository,
-            IMediator mediator,
-            IFFmpegProcessServiceFactory ffmpegProcessServiceFactory,
-            ITempFilePool tempFilePool,
-            ILogger<TelevisionFolderScanner> logger) : base(
-            localFileSystem,
-            localStatisticsProvider,
-            metadataRepository,
-            mediaItemRepository,
-            imageCache,
-            ffmpegProcessServiceFactory,
-            tempFilePool,
-            logger)
+    public async Task<Either<BaseError, Unit>> ScanFolder(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        decimal progressMin,
+        decimal progressMax)
+    {
+        decimal progressSpread = progressMax - progressMin;
+
+        var allShowFolders = _localFileSystem.ListSubdirectories(libraryPath.Path)
+            .Filter(ShouldIncludeFolder)
+            .OrderBy(identity)
+            .ToList();
+
+        foreach (string showFolder in allShowFolders)
         {
-            _localFileSystem = localFileSystem;
-            _televisionRepository = televisionRepository;
-            _localMetadataProvider = localMetadataProvider;
-            _metadataRepository = metadataRepository;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _libraryRepository = libraryRepository;
-            _mediator = mediator;
-            _logger = logger;
+            decimal percentCompletion = (decimal) allShowFolders.IndexOf(showFolder) / allShowFolders.Count;
+            await _mediator.Publish(
+                new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
+
+            Either<BaseError, MediaItemScanResult<Show>> maybeShow =
+                await FindOrCreateShow(libraryPath.Id, showFolder)
+                    .BindT(show => UpdateMetadataForShow(show, showFolder))
+                    .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.Poster))
+                    .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.FanArt))
+                    .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.Thumbnail));
+
+            await maybeShow.Match(
+                async result =>
+                {
+                    await ScanSeasons(
+                        libraryPath,
+                        ffprobePath,
+                        result.Item,
+                        showFolder);
+
+                    if (result.IsAdded)
+                    {
+                        await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                    }
+                    else if (result.IsUpdated)
+                    {
+                        await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
+                    }
+                },
+                error =>
+                {
+                    _logger.LogWarning(
+                        "Error processing show in folder {Folder}: {Error}",
+                        showFolder,
+                        error.Value);
+                    return Task.FromResult(Unit.Default);
+                });
         }
 
-        public async Task<Either<BaseError, Unit>> ScanFolder(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            decimal progressMin,
-            decimal progressMax)
+        foreach (string path in await _televisionRepository.FindEpisodePaths(libraryPath))
         {
-            decimal progressSpread = progressMax - progressMin;
-
-            var allShowFolders = _localFileSystem.ListSubdirectories(libraryPath.Path)
-                .Filter(ShouldIncludeFolder)
-                .OrderBy(identity)
-                .ToList();
-
-            foreach (string showFolder in allShowFolders)
+            if (!_localFileSystem.FileExists(path))
             {
-                decimal percentCompletion = (decimal) allShowFolders.IndexOf(showFolder) / allShowFolders.Count;
-                await _mediator.Publish(
-                    new LibraryScanProgress(libraryPath.LibraryId, progressMin + percentCompletion * progressSpread));
-
-                Either<BaseError, MediaItemScanResult<Show>> maybeShow =
-                    await FindOrCreateShow(libraryPath.Id, showFolder)
-                        .BindT(show => UpdateMetadataForShow(show, showFolder))
-                        .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.Poster))
-                        .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.FanArt))
-                        .BindT(show => UpdateArtworkForShow(show, showFolder, ArtworkKind.Thumbnail));
-
-                await maybeShow.Match(
-                    async result =>
-                    {
-                        await ScanSeasons(
-                            libraryPath,
-                            ffprobePath,
-                            result.Item,
-                            showFolder);
-
-                        if (result.IsAdded)
-                        {
-                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
-                        }
-                        else if (result.IsUpdated)
-                        {
-                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { result.Item });
-                        }
-                    },
-                    error =>
-                    {
-                        _logger.LogWarning(
-                            "Error processing show in folder {Folder}: {Error}",
-                            showFolder,
-                            error.Value);
-                        return Task.FromResult(Unit.Default);
-                    });
+                _logger.LogInformation("Flagging missing episode at {Path}", path);
+                List<int> episodeIds = await FlagFileNotFound(libraryPath, path);
+                await _searchIndex.RebuildItems(_searchRepository, episodeIds);
             }
-
-            foreach (string path in await _televisionRepository.FindEpisodePaths(libraryPath))
+            else if (Path.GetFileName(path).StartsWith("._"))
             {
-                if (!_localFileSystem.FileExists(path))
-                {
-                    _logger.LogInformation("Flagging missing episode at {Path}", path);
-                    List<int> episodeIds = await FlagFileNotFound(libraryPath, path);
-                    await _searchIndex.RebuildItems(_searchRepository, episodeIds);
-                }
-                else if (Path.GetFileName(path).StartsWith("._"))
-                {
-                    _logger.LogInformation("Removing dot underscore file at {Path}", path);
-                    await _televisionRepository.DeleteByPath(libraryPath, path);
-                }
+                _logger.LogInformation("Removing dot underscore file at {Path}", path);
+                await _televisionRepository.DeleteByPath(libraryPath, path);
             }
+        }
             
-            await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
+        await _libraryRepository.CleanEtagsForLibraryPath(libraryPath);
 
-            await _televisionRepository.DeleteEmptySeasons(libraryPath);
-            List<int> ids = await _televisionRepository.DeleteEmptyShows(libraryPath);
-            await _searchIndex.RemoveItems(ids);
+        await _televisionRepository.DeleteEmptySeasons(libraryPath);
+        List<int> ids = await _televisionRepository.DeleteEmptyShows(libraryPath);
+        await _searchIndex.RemoveItems(ids);
 
-            _searchIndex.Commit();
-            return Unit.Default;
-        }
+        _searchIndex.Commit();
+        return Unit.Default;
+    }
 
-        private async Task<Either<BaseError, MediaItemScanResult<Show>>> FindOrCreateShow(
-            int libraryPathId,
-            string showFolder)
+    private async Task<Either<BaseError, MediaItemScanResult<Show>>> FindOrCreateShow(
+        int libraryPathId,
+        string showFolder)
+    {
+        ShowMetadata metadata = await _localMetadataProvider.GetMetadataForShow(showFolder);
+        Option<Show> maybeShow = await _televisionRepository.GetShowByMetadata(libraryPathId, metadata);
+        return await maybeShow.Match(
+            show => Right<BaseError, MediaItemScanResult<Show>>(new MediaItemScanResult<Show>(show)).AsTask(),
+            async () => await _televisionRepository.AddShow(libraryPathId, showFolder, metadata));
+    }
+
+    private async Task<Unit> ScanSeasons(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        Show show,
+        string showFolder)
+    {
+        foreach (string seasonFolder in _localFileSystem.ListSubdirectories(showFolder).Filter(ShouldIncludeFolder)
+                     .OrderBy(identity))
         {
-            ShowMetadata metadata = await _localMetadataProvider.GetMetadataForShow(showFolder);
-            Option<Show> maybeShow = await _televisionRepository.GetShowByMetadata(libraryPathId, metadata);
-            return await maybeShow.Match(
-                show => Right<BaseError, MediaItemScanResult<Show>>(new MediaItemScanResult<Show>(show)).AsTask(),
-                async () => await _televisionRepository.AddShow(libraryPathId, showFolder, metadata));
-        }
+            string etag = FolderEtag.CalculateWithSubfolders(seasonFolder, _localFileSystem);
+            Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
+                .Filter(f => f.Path == seasonFolder)
+                .HeadOrNone();
 
-        private async Task<Unit> ScanSeasons(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            Show show,
-            string showFolder)
-        {
-            foreach (string seasonFolder in _localFileSystem.ListSubdirectories(showFolder).Filter(ShouldIncludeFolder)
-                .OrderBy(identity))
+            // skip folder if etag matches
+            if (await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
             {
-                string etag = FolderEtag.CalculateWithSubfolders(seasonFolder, _localFileSystem);
-                Option<LibraryFolder> knownFolder = libraryPath.LibraryFolders
-                    .Filter(f => f.Path == seasonFolder)
-                    .HeadOrNone();
+                continue;
+            }
 
-                // skip folder if etag matches
-                if (await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
+            Option<int> maybeSeasonNumber = SeasonNumberForFolder(seasonFolder);
+            await maybeSeasonNumber.IfSomeAsync(
+                async seasonNumber =>
                 {
-                    continue;
-                }
+                    Either<BaseError, Season> maybeSeason = await _televisionRepository
+                        .GetOrAddSeason(show, libraryPath.Id, seasonNumber)
+                        .BindT(EnsureMetadataExists)
+                        .BindT(season => UpdatePoster(season, seasonFolder));
 
-                Option<int> maybeSeasonNumber = SeasonNumberForFolder(seasonFolder);
-                await maybeSeasonNumber.IfSomeAsync(
-                    async seasonNumber =>
-                    {
-                        Either<BaseError, Season> maybeSeason = await _televisionRepository
-                            .GetOrAddSeason(show, libraryPath.Id, seasonNumber)
-                            .BindT(EnsureMetadataExists)
-                            .BindT(season => UpdatePoster(season, seasonFolder));
-
-                        await maybeSeason.Match(
-                            async season =>
-                            {
-                                await ScanEpisodes(libraryPath, ffprobePath, season, seasonFolder);
-                                await _libraryRepository.SetEtag(libraryPath, knownFolder, seasonFolder, etag);
-
-                                season.Show = show;
-                                await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { season });
-                            },
-                            error =>
-                            {
-                                _logger.LogWarning(
-                                    "Error processing season in folder {Folder}: {Error}",
-                                    seasonFolder,
-                                    error.Value);
-                                return Task.FromResult(Unit.Default);
-                            });
-                    });
-            }
-
-            return Unit.Default;
-        }
-
-        private async Task<Unit> ScanEpisodes(
-            LibraryPath libraryPath,
-            string ffprobePath,
-            Season season,
-            string seasonPath)
-        {
-            var allSeasonFiles = _localFileSystem.ListSubdirectories(seasonPath)
-                .Map(_localFileSystem.ListFiles)
-                .Flatten()
-                .Append(_localFileSystem.ListFiles(seasonPath))
-                .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
-                .Filter(f => !Path.GetFileName(f).StartsWith("._"))
-                .OrderBy(identity)
-                .ToList();
-
-            foreach (string file in allSeasonFiles)
-            {
-                // TODO: figure out how to rebuild playlists
-                Either<BaseError, Episode> maybeEpisode = await _televisionRepository
-                    .GetOrAddEpisode(season, libraryPath, file)
-                    .BindT(
-                        episode => UpdateStatistics(new MediaItemScanResult<Episode>(episode), ffprobePath)
-                            .MapT(_ => episode))
-                    .BindT(UpdateMetadata)
-                    .BindT(UpdateThumbnail)
-                    .BindT(e => FlagNormal(new MediaItemScanResult<Episode>(e)))
-                    .MapT(r => r.Item);
-
-                await maybeEpisode.Match(
-                    async episode =>
-                    {
-                        await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { episode });
-                    },
-                    error =>
-                    {
-                        _logger.LogWarning("Error processing episode at {Path}: {Error}", file, error.Value);
-                        return Task.CompletedTask;
-                    });
-            }
-
-            // TODO: remove missing episodes?
-
-            return Unit.Default;
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Show>>> UpdateMetadataForShow(
-            MediaItemScanResult<Show> result,
-            string showFolder)
-        {
-            try
-            {
-                Show show = result.Item;
-                await LocateNfoFileForShow(showFolder).Match(
-                    async nfoFile =>
-                    {
-                        bool shouldUpdate = Optional(show.ShowMetadata).Flatten().HeadOrNone().Match(
-                            m => m.MetadataKind == MetadataKind.Fallback ||
-                                 m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
-                            true);
-
-                        if (shouldUpdate)
+                    await maybeSeason.Match(
+                        async season =>
                         {
-                            _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
-                            if (await _localMetadataProvider.RefreshSidecarMetadata(show, nfoFile))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-                    },
-                    async () =>
-                    {
-                        if (!Optional(show.ShowMetadata).Flatten().Any())
-                        {
-                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", showFolder);
-                            if (await _localMetadataProvider.RefreshFallbackMetadata(show, showFolder))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-                    });
+                            await ScanEpisodes(libraryPath, ffprobePath, season, seasonFolder);
+                            await _libraryRepository.SetEtag(libraryPath, knownFolder, seasonFolder, etag);
 
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
+                            season.Show = show;
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { season });
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning(
+                                "Error processing season in folder {Folder}: {Error}",
+                                seasonFolder,
+                                error.Value);
+                            return Task.FromResult(Unit.Default);
+                        });
+                });
         }
 
-        private async Task<Either<BaseError, Season>> EnsureMetadataExists(Season season)
-        {
-            season.SeasonMetadata ??= new List<SeasonMetadata>();
+        return Unit.Default;
+    }
 
-            if (!season.SeasonMetadata.Any())
-            {
-                var metadata = new SeasonMetadata
+    private async Task<Unit> ScanEpisodes(
+        LibraryPath libraryPath,
+        string ffprobePath,
+        Season season,
+        string seasonPath)
+    {
+        var allSeasonFiles = _localFileSystem.ListSubdirectories(seasonPath)
+            .Map(_localFileSystem.ListFiles)
+            .Flatten()
+            .Append(_localFileSystem.ListFiles(seasonPath))
+            .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
+            .Filter(f => !Path.GetFileName(f).StartsWith("._"))
+            .OrderBy(identity)
+            .ToList();
+
+        foreach (string file in allSeasonFiles)
+        {
+            // TODO: figure out how to rebuild playlists
+            Either<BaseError, Episode> maybeEpisode = await _televisionRepository
+                .GetOrAddEpisode(season, libraryPath, file)
+                .BindT(
+                    episode => UpdateStatistics(new MediaItemScanResult<Episode>(episode), ffprobePath)
+                        .MapT(_ => episode))
+                .BindT(UpdateMetadata)
+                .BindT(UpdateThumbnail)
+                .BindT(e => FlagNormal(new MediaItemScanResult<Episode>(e)))
+                .MapT(r => r.Item);
+
+            await maybeEpisode.Match(
+                async episode =>
                 {
-                    SeasonId = season.Id,
-                    Season = season,
-                    DateAdded = DateTime.UtcNow,
-                    Guids = new List<MetadataGuid>()
-                };
+                    await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { episode });
+                },
+                error =>
+                {
+                    _logger.LogWarning("Error processing episode at {Path}: {Error}", file, error.Value);
+                    return Task.CompletedTask;
+                });
+        }
 
-                season.SeasonMetadata.Add(metadata);
-                await _metadataRepository.Add(metadata);
-            }
+        // TODO: remove missing episodes?
+
+        return Unit.Default;
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<Show>>> UpdateMetadataForShow(
+        MediaItemScanResult<Show> result,
+        string showFolder)
+    {
+        try
+        {
+            Show show = result.Item;
+            await LocateNfoFileForShow(showFolder).Match(
+                async nfoFile =>
+                {
+                    bool shouldUpdate = Optional(show.ShowMetadata).Flatten().HeadOrNone().Match(
+                        m => m.MetadataKind == MetadataKind.Fallback ||
+                             m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
+                        true);
+
+                    if (shouldUpdate)
+                    {
+                        _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
+                        if (await _localMetadataProvider.RefreshSidecarMetadata(show, nfoFile))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+                },
+                async () =>
+                {
+                    if (!Optional(show.ShowMetadata).Flatten().Any())
+                    {
+                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", showFolder);
+                        if (await _localMetadataProvider.RefreshFallbackMetadata(show, showFolder))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+                });
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private async Task<Either<BaseError, Season>> EnsureMetadataExists(Season season)
+    {
+        season.SeasonMetadata ??= new List<SeasonMetadata>();
+
+        if (!season.SeasonMetadata.Any())
+        {
+            var metadata = new SeasonMetadata
+            {
+                SeasonId = season.Id,
+                Season = season,
+                DateAdded = DateTime.UtcNow,
+                Guids = new List<MetadataGuid>()
+            };
+
+            season.SeasonMetadata.Add(metadata);
+            await _metadataRepository.Add(metadata);
+        }
+
+        return season;
+    }
+
+    private async Task<Either<BaseError, Episode>> UpdateMetadata(Episode episode)
+    {
+        try
+        {
+            await LocateNfoFile(episode).Match(
+                async nfoFile =>
+                {
+                    bool shouldUpdate = Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
+                        m => m.MetadataKind == MetadataKind.Fallback ||
+                             m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
+                        true);
+
+                    if (shouldUpdate)
+                    {
+                        _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
+                        await _localMetadataProvider.RefreshSidecarMetadata(episode, nfoFile);
+                    }
+                },
+                async () =>
+                {
+                    bool shouldUpdate = Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
+                        m => m.DateUpdated == SystemTime.MinValueUtc,
+                        true);
+
+                    if (shouldUpdate)
+                    {
+                        string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
+                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
+                        await _localMetadataProvider.RefreshFallbackMetadata(episode);
+                    }
+                });
+
+            return episode;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<Show>>> UpdateArtworkForShow(
+        MediaItemScanResult<Show> result,
+        string showFolder,
+        ArtworkKind artworkKind)
+    {
+        try
+        {
+            Show show = result.Item;
+            await LocateArtworkForShow(showFolder, artworkKind).IfSomeAsync(
+                async artworkFile =>
+                {
+                    ShowMetadata metadata = show.ShowMetadata.Head();
+                    await RefreshArtwork(artworkFile, metadata, artworkKind, None, None);
+                });
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private async Task<Either<BaseError, Season>> UpdatePoster(Season season, string seasonFolder)
+    {
+        try
+        {
+            await LocatePoster(season, seasonFolder).IfSomeAsync(
+                async posterFile =>
+                {
+                    SeasonMetadata metadata = season.SeasonMetadata.Head();
+                    await RefreshArtwork(posterFile, metadata, ArtworkKind.Poster, None, None);
+                });
 
             return season;
         }
-
-        private async Task<Either<BaseError, Episode>> UpdateMetadata(Episode episode)
+        catch (Exception ex)
         {
-            try
-            {
-                await LocateNfoFile(episode).Match(
-                    async nfoFile =>
-                    {
-                        bool shouldUpdate = Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
-                            m => m.MetadataKind == MetadataKind.Fallback ||
-                                 m.DateUpdated != _localFileSystem.GetLastWriteTime(nfoFile),
-                            true);
-
-                        if (shouldUpdate)
-                        {
-                            _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
-                            await _localMetadataProvider.RefreshSidecarMetadata(episode, nfoFile);
-                        }
-                    },
-                    async () =>
-                    {
-                        bool shouldUpdate = Optional(episode.EpisodeMetadata).Flatten().HeadOrNone().Match(
-                            m => m.DateUpdated == SystemTime.MinValueUtc,
-                            true);
-
-                        if (shouldUpdate)
-                        {
-                            string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
-                            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
-                            await _localMetadataProvider.RefreshFallbackMetadata(episode);
-                        }
-                    });
-
-                return episode;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<Show>>> UpdateArtworkForShow(
-            MediaItemScanResult<Show> result,
-            string showFolder,
-            ArtworkKind artworkKind)
-        {
-            try
-            {
-                Show show = result.Item;
-                await LocateArtworkForShow(showFolder, artworkKind).IfSomeAsync(
-                    async artworkFile =>
-                    {
-                        ShowMetadata metadata = show.ShowMetadata.Head();
-                        await RefreshArtwork(artworkFile, metadata, artworkKind, None, None);
-                    });
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private async Task<Either<BaseError, Season>> UpdatePoster(Season season, string seasonFolder)
-        {
-            try
-            {
-                await LocatePoster(season, seasonFolder).IfSomeAsync(
-                    async posterFile =>
-                    {
-                        SeasonMetadata metadata = season.SeasonMetadata.Head();
-                        await RefreshArtwork(posterFile, metadata, ArtworkKind.Poster, None, None);
-                    });
-
-                return season;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private async Task<Either<BaseError, Episode>> UpdateThumbnail(Episode episode)
-        {
-            try
-            {
-                await LocateThumbnail(episode).IfSomeAsync(
-                    async posterFile =>
-                    {
-                        foreach (EpisodeMetadata metadata in episode.EpisodeMetadata)
-                        {
-                            await RefreshArtwork(posterFile, metadata, ArtworkKind.Thumbnail, None, None);
-                        }
-                    });
-
-                return episode;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private Option<string> LocateNfoFileForShow(string showFolder) =>
-            Optional(Path.Combine(showFolder, "tvshow.nfo"))
-                .Filter(s => _localFileSystem.FileExists(s));
-
-        private Option<string> LocateNfoFile(Episode episode)
-        {
-            string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
-            return Optional(Path.ChangeExtension(path, "nfo"))
-                .Filter(s => _localFileSystem.FileExists(s));
-        }
-
-        private Option<string> LocateArtworkForShow(string showFolder, ArtworkKind artworkKind)
-        {
-            string[] segments = artworkKind switch
-            {
-                ArtworkKind.Poster => new[] { "poster", "folder" },
-                ArtworkKind.FanArt => new[] { "fanart" },
-                ArtworkKind.Thumbnail => new[] { "thumb" },
-                _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
-            };
-
-            return ImageFileExtensions
-                .Map(ext => segments.Map(segment => $"{segment}.{ext}"))
-                .Flatten()
-                .Map(f => Path.Combine(showFolder, f))
-                .Filter(s => _localFileSystem.FileExists(s))
-                .HeadOrNone();
-        }
-
-        private Option<string> LocatePoster(Season season, string seasonFolder)
-        {
-            string folder = Path.GetDirectoryName(seasonFolder) ?? string.Empty;
-            return ImageFileExtensions
-                .Map(ext => Path.Combine(folder, $"season{season.SeasonNumber:00}-poster.{ext}"))
-                .Filter(s => _localFileSystem.FileExists(s))
-                .HeadOrNone();
-        }
-
-        private Option<string> LocateThumbnail(Episode episode)
-        {
-            string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
-            string folder = Path.GetDirectoryName(path) ?? string.Empty;
-            return ImageFileExtensions
-                .Map(ext => Path.GetFileNameWithoutExtension(path) + $"-thumb.{ext}")
-                .Map(f => Path.Combine(folder, f))
-                .Filter(f => _localFileSystem.FileExists(f))
-                .HeadOrNone();
-        }
-
-        private static Option<int> SeasonNumberForFolder(string folder)
-        {
-            if (int.TryParse(folder.Split(" ").Last(), out int seasonNumber))
-            {
-                return seasonNumber;
-            }
-
-            if (folder.EndsWith("specials", StringComparison.OrdinalIgnoreCase))
-            {
-                return 0;
-            }
-
-            return None;
+            return BaseError.New(ex.ToString());
         }
     }
-}
+
+    private async Task<Either<BaseError, Episode>> UpdateThumbnail(Episode episode)
+    {
+        try
+        {
+            await LocateThumbnail(episode).IfSomeAsync(
+                async posterFile =>
+                {
+                    foreach (EpisodeMetadata metadata in episode.EpisodeMetadata)
+                    {
+                        await RefreshArtwork(posterFile, metadata, ArtworkKind.Thumbnail, None, None);
+                    }
+                });
+
+            return episode;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private Option<string> LocateNfoFileForShow(string showFolder) =>
+        Optional(Path.Combine(showFolder, "tvshow.nfo"))
+            .Filter(s => _localFileSystem.FileExists(s));
+
+    private Option<string> LocateNfoFile(Episode episode)
+    {
+        string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
+        return Optional(Path.ChangeExtension(path, "nfo"))
+            .Filter(s => _localFileSystem.FileExists(s));
+    }
+
+    private Option<string> LocateArtworkForShow(string showFolder, ArtworkKind artworkKind)
+    {
+        string[] segments = artworkKind switch
+        {
+            ArtworkKind.Poster => new[] { "poster", "folder" },
+            ArtworkKind.FanArt => new[] { "fanart" },
+            ArtworkKind.Thumbnail => new[] { "thumb" },
+            _ => throw new ArgumentOutOfRangeException(nameof(artworkKind))
+        };
+
+        return ImageFileExtensions
+            .Map(ext => segments.Map(segment => $"{segment}.{ext}"))
+            .Flatten()
+            .Map(f => Path.Combine(showFolder, f))
+            .Filter(s => _localFileSystem.FileExists(s))
+            .HeadOrNone();
+    }
+
+    private Option<string> LocatePoster(Season season, string seasonFolder)
+    {
+        string folder = Path.GetDirectoryName(seasonFolder) ?? string.Empty;
+        return ImageFileExtensions
+            .Map(ext => Path.Combine(folder, $"season{season.SeasonNumber:00}-poster.{ext}"))
+            .Filter(s => _localFileSystem.FileExists(s))
+            .HeadOrNone();
+    }
+
+    private Option<string> LocateThumbnail(Episode episode)
+    {
+        string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
+        string folder = Path.GetDirectoryName(path) ?? string.Empty;
+        return ImageFileExtensions
+            .Map(ext => Path.GetFileNameWithoutExtension(path) + $"-thumb.{ext}")
+            .Map(f => Path.Combine(folder, f))
+            .Filter(f => _localFileSystem.FileExists(f))
+            .HeadOrNone();
+    }
+
+    private static Option<int> SeasonNumberForFolder(string folder)
+    {
+        if (int.TryParse(folder.Split(" ").Last(), out int seasonNumber))
+        {
+            return seasonNumber;
+        }
+
+        if (folder.EndsWith("specials", StringComparison.OrdinalIgnoreCase))
+        {
+            return 0;
+        }
+
+        return None;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Plex/PlexAuthPin.cs b/ErsatzTV.Core/Plex/PlexAuthPin.cs
index 85e14f0e3..9bdc79bff 100644
--- a/ErsatzTV.Core/Plex/PlexAuthPin.cs
+++ b/ErsatzTV.Core/Plex/PlexAuthPin.cs
@@ -1,16 +1,15 @@
-namespace ErsatzTV.Core.Plex
+namespace ErsatzTV.Core.Plex;
+
+public record PlexAuthPin(int Id, string Code, string ClientIdentifier)
 {
-    public record PlexAuthPin(int Id, string Code, string ClientIdentifier)
+    public string Url
     {
-        public string Url
+        get
         {
-            get
-            {
-                var clientId = $"clientID={ClientIdentifier}";
-                var code = $"code={Code}";
-                var cdp = "context%5Bdevice%5D%5Bproduct%5D=ErsatzTV";
-                return $"https://app.plex.tv/auth#?{clientId}&{code}&{cdp}";
-            }
+            var clientId = $"clientID={ClientIdentifier}";
+            var code = $"code={Code}";
+            var cdp = "context%5Bdevice%5D%5Bproduct%5D=ErsatzTV";
+            return $"https://app.plex.tv/auth#?{clientId}&{code}&{cdp}";
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Plex/PlexLibraryScanner.cs b/ErsatzTV.Core/Plex/PlexLibraryScanner.cs
index 4f23c0172..f86548b75 100644
--- a/ErsatzTV.Core/Plex/PlexLibraryScanner.cs
+++ b/ErsatzTV.Core/Plex/PlexLibraryScanner.cs
@@ -1,65 +1,60 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Plex
+namespace ErsatzTV.Core.Plex;
+
+public abstract class PlexLibraryScanner
 {
-    public abstract class PlexLibraryScanner
+    private readonly ILogger<PlexLibraryScanner> _logger;
+    private readonly IMetadataRepository _metadataRepository;
+
+    protected PlexLibraryScanner(IMetadataRepository metadataRepository, ILogger<PlexLibraryScanner> logger)
     {
-        private readonly ILogger<PlexLibraryScanner> _logger;
-        private readonly IMetadataRepository _metadataRepository;
-
-        protected PlexLibraryScanner(IMetadataRepository metadataRepository, ILogger<PlexLibraryScanner> logger)
-        {
-            _metadataRepository = metadataRepository;
-            _logger = logger;
-        }
-
-        protected async Task<Unit> UpdateArtworkIfNeeded(
-            Domain.Metadata existingMetadata,
-            Domain.Metadata incomingMetadata,
-            ArtworkKind artworkKind)
-        {
-            if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
-            {
-                Option<Artwork> maybeIncomingArtwork = Optional(incomingMetadata.Artwork).Flatten()
-                    .Find(a => a.ArtworkKind == artworkKind);
-
-                await maybeIncomingArtwork.Match(
-                    async incomingArtwork =>
-                    {
-                        _logger.LogDebug("Refreshing Plex {Attribute} from {Path}", artworkKind, incomingArtwork.Path);
-
-                        Option<Artwork> maybeExistingArtwork = Optional(existingMetadata.Artwork).Flatten()
-                            .Find(a => a.ArtworkKind == artworkKind);
-
-                        await maybeExistingArtwork.Match(
-                            async existingArtwork =>
-                            {
-                                existingArtwork.Path = incomingArtwork.Path;
-                                existingArtwork.DateUpdated = incomingArtwork.DateUpdated;
-                                await _metadataRepository.UpdateArtworkPath(existingArtwork);
-                            },
-                            async () =>
-                            {
-                                existingMetadata.Artwork ??= new List<Artwork>();
-                                existingMetadata.Artwork.Add(incomingArtwork);
-                                await _metadataRepository.AddArtwork(existingMetadata, incomingArtwork);
-                            });
-                    },
-                    async () =>
-                    {
-                        existingMetadata.Artwork ??= new List<Artwork>();
-                        existingMetadata.Artwork.RemoveAll(a => a.ArtworkKind == artworkKind);
-                        await _metadataRepository.RemoveArtwork(existingMetadata, artworkKind);
-                    });
-            }
-
-            return Unit.Default;
-        }
+        _metadataRepository = metadataRepository;
+        _logger = logger;
     }
-}
+
+    protected async Task<Unit> UpdateArtworkIfNeeded(
+        Domain.Metadata existingMetadata,
+        Domain.Metadata incomingMetadata,
+        ArtworkKind artworkKind)
+    {
+        if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
+        {
+            Option<Artwork> maybeIncomingArtwork = Optional(incomingMetadata.Artwork).Flatten()
+                .Find(a => a.ArtworkKind == artworkKind);
+
+            await maybeIncomingArtwork.Match(
+                async incomingArtwork =>
+                {
+                    _logger.LogDebug("Refreshing Plex {Attribute} from {Path}", artworkKind, incomingArtwork.Path);
+
+                    Option<Artwork> maybeExistingArtwork = Optional(existingMetadata.Artwork).Flatten()
+                        .Find(a => a.ArtworkKind == artworkKind);
+
+                    await maybeExistingArtwork.Match(
+                        async existingArtwork =>
+                        {
+                            existingArtwork.Path = incomingArtwork.Path;
+                            existingArtwork.DateUpdated = incomingArtwork.DateUpdated;
+                            await _metadataRepository.UpdateArtworkPath(existingArtwork);
+                        },
+                        async () =>
+                        {
+                            existingMetadata.Artwork ??= new List<Artwork>();
+                            existingMetadata.Artwork.Add(incomingArtwork);
+                            await _metadataRepository.AddArtwork(existingMetadata, incomingArtwork);
+                        });
+                },
+                async () =>
+                {
+                    existingMetadata.Artwork ??= new List<Artwork>();
+                    existingMetadata.Artwork.RemoveAll(a => a.ArtworkKind == artworkKind);
+                    await _metadataRepository.RemoveArtwork(existingMetadata, artworkKind);
+                });
+        }
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs b/ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs
index 5f22045dc..109aa4eea 100644
--- a/ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs
+++ b/ErsatzTV.Core/Plex/PlexMovieLibraryScanner.cs
@@ -1,429 +1,423 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Plex
+namespace ErsatzTV.Core.Plex;
+
+public class PlexMovieLibraryScanner : PlexLibraryScanner, IPlexMovieLibraryScanner
 {
-    public class PlexMovieLibraryScanner : PlexLibraryScanner, IPlexMovieLibraryScanner
-    {
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly ILogger<PlexMovieLibraryScanner> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMediator _mediator;
-        private readonly IMetadataRepository _metadataRepository;
-        private readonly IMovieRepository _movieRepository;
-        private readonly IPlexPathReplacementService _plexPathReplacementService;
-        private readonly IPlexServerApiClient _plexServerApiClient;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalStatisticsProvider _localStatisticsProvider;
+    private readonly ILogger<PlexMovieLibraryScanner> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediator _mediator;
+    private readonly IMetadataRepository _metadataRepository;
+    private readonly IMovieRepository _movieRepository;
+    private readonly IPlexPathReplacementService _plexPathReplacementService;
+    private readonly IPlexServerApiClient _plexServerApiClient;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
 
-        public PlexMovieLibraryScanner(
-            IPlexServerApiClient plexServerApiClient,
-            IMovieRepository movieRepository,
-            IMetadataRepository metadataRepository,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            IMediator mediator,
-            IMediaSourceRepository mediaSourceRepository,
-            IPlexPathReplacementService plexPathReplacementService,
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILogger<PlexMovieLibraryScanner> logger)
-            : base(metadataRepository, logger)
+    public PlexMovieLibraryScanner(
+        IPlexServerApiClient plexServerApiClient,
+        IMovieRepository movieRepository,
+        IMetadataRepository metadataRepository,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        IMediator mediator,
+        IMediaSourceRepository mediaSourceRepository,
+        IPlexPathReplacementService plexPathReplacementService,
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILogger<PlexMovieLibraryScanner> logger)
+        : base(metadataRepository, logger)
+    {
+        _plexServerApiClient = plexServerApiClient;
+        _movieRepository = movieRepository;
+        _metadataRepository = metadataRepository;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _mediator = mediator;
+        _mediaSourceRepository = mediaSourceRepository;
+        _plexPathReplacementService = plexPathReplacementService;
+        _localFileSystem = localFileSystem;
+        _localStatisticsProvider = localStatisticsProvider;
+        _logger = logger;
+    }
+
+    public async Task<Either<BaseError, Unit>> ScanLibrary(
+        PlexConnection connection,
+        PlexServerAuthToken token,
+        PlexLibrary library,
+        string ffprobePath)
+    {
+        List<PlexPathReplacement> pathReplacements = await _mediaSourceRepository
+            .GetPlexPathReplacements(library.MediaSourceId);
+
+        Either<BaseError, List<PlexMovie>> entries = await _plexServerApiClient.GetMovieLibraryContents(
+            library,
+            connection,
+            token);
+
+        await entries.Match(
+            async movieEntries =>
+            {
+                var validMovies = new List<PlexMovie>();
+                foreach (PlexMovie movie in movieEntries.OrderBy(m => m.MovieMetadata.Head().Title))
+                {
+                    string localPath = _plexPathReplacementService.GetReplacementPlexPath(
+                        pathReplacements,
+                        movie.MediaVersions.Head().MediaFiles.Head().Path,
+                        false);
+
+                    if (!_localFileSystem.FileExists(localPath))
+                    {
+                        _logger.LogWarning("Skipping plex movie that does not exist at {Path}", localPath);
+                    }
+                    else
+                    {
+                        validMovies.Add(movie);
+                    }
+                }
+
+                foreach (PlexMovie incoming in validMovies)
+                {
+                    decimal percentCompletion = (decimal) validMovies.IndexOf(incoming) / validMovies.Count;
+                    await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
+
+                    // TODO: figure out how to rebuild playlists
+                    Either<BaseError, MediaItemScanResult<PlexMovie>> maybeMovie = await _movieRepository
+                        .GetOrAdd(library, incoming)
+                        .BindT(existing => UpdateStatistics(pathReplacements, existing, incoming, ffprobePath))
+                        .BindT(existing => UpdateMetadata(existing, incoming, library, connection, token))
+                        .BindT(existing => UpdateArtwork(existing, incoming));
+
+                    await maybeMovie.Match(
+                        async result =>
+                        {
+                            if (result.IsAdded)
+                            {
+                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                            }
+                            else if (result.IsUpdated)
+                            {
+                                await _searchIndex.UpdateItems(
+                                    _searchRepository,
+                                    new List<MediaItem> { result.Item });
+                            }
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning(
+                                "Error processing plex movie at {Key}: {Error}",
+                                incoming.Key,
+                                error.Value);
+                            return Task.CompletedTask;
+                        });
+                }
+
+                var movieKeys = validMovies.Map(s => s.Key).ToList();
+                List<int> ids = await _movieRepository.RemoveMissingPlexMovies(library, movieKeys);
+                await _searchIndex.RemoveItems(ids);
+
+                await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing plex library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
+
+                return Task.CompletedTask;
+            });
+
+        _searchIndex.Commit();
+        return Unit.Default;
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateStatistics(
+        List<PlexPathReplacement> pathReplacements,
+        MediaItemScanResult<PlexMovie> result,
+        PlexMovie incoming,
+        string ffprobePath)
+    {
+        PlexMovie existing = result.Item;
+        MediaVersion existingVersion = existing.MediaVersions.Head();
+        MediaVersion incomingVersion = incoming.MediaVersions.Head();
+
+        foreach (MediaFile incomingFile in incomingVersion.MediaFiles.HeadOrNone())
         {
-            _plexServerApiClient = plexServerApiClient;
-            _movieRepository = movieRepository;
-            _metadataRepository = metadataRepository;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _mediator = mediator;
-            _mediaSourceRepository = mediaSourceRepository;
-            _plexPathReplacementService = plexPathReplacementService;
-            _localFileSystem = localFileSystem;
-            _localStatisticsProvider = localStatisticsProvider;
-            _logger = logger;
+            foreach (MediaFile existingFile in existingVersion.MediaFiles.HeadOrNone())
+            {
+                if (incomingFile.Path != existingFile.Path)
+                {
+                    _logger.LogDebug(
+                        "Plex movie has moved from {OldPath} to {NewPath}",
+                        existingFile.Path,
+                        incomingFile.Path);
+
+                    existingFile.Path = incomingFile.Path;
+
+                    await _movieRepository.UpdatePath(existingFile.Id, incomingFile.Path);
+                }
+            }
         }
 
-        public async Task<Either<BaseError, Unit>> ScanLibrary(
-            PlexConnection connection,
-            PlexServerAuthToken token,
-            PlexLibrary library,
-            string ffprobePath)
+        if (incomingVersion.DateUpdated > existingVersion.DateUpdated || !existingVersion.Streams.Any())
         {
-            List<PlexPathReplacement> pathReplacements = await _mediaSourceRepository
-                .GetPlexPathReplacements(library.MediaSourceId);
-
-            Either<BaseError, List<PlexMovie>> entries = await _plexServerApiClient.GetMovieLibraryContents(
-                library,
-                connection,
-                token);
-
-            await entries.Match(
-                async movieEntries =>
+            string localPath = _plexPathReplacementService.GetReplacementPlexPath(
+                pathReplacements,
+                incoming.MediaVersions.Head().MediaFiles.Head().Path,
+                false);
+                
+            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
+            Either<BaseError, bool> refreshResult =
+                await _localStatisticsProvider.RefreshStatistics(ffprobePath, existing, localPath);
+                
+            await refreshResult.Match(
+                async _ =>
                 {
-                    var validMovies = new List<PlexMovie>();
-                    foreach (PlexMovie movie in movieEntries.OrderBy(m => m.MovieMetadata.Head().Title))
+                    foreach (MediaItem updated in await _searchRepository.GetItemToIndex(incoming.Id))
                     {
-                        string localPath = _plexPathReplacementService.GetReplacementPlexPath(
-                            pathReplacements,
-                            movie.MediaVersions.Head().MediaFiles.Head().Path,
-                            false);
-
-                        if (!_localFileSystem.FileExists(localPath))
-                        {
-                            _logger.LogWarning("Skipping plex movie that does not exist at {Path}", localPath);
-                        }
-                        else
-                        {
-                            validMovies.Add(movie);
-                        }
+                        await _searchIndex.UpdateItems(
+                            _searchRepository,
+                            new List<MediaItem> { updated });
                     }
 
-                    foreach (PlexMovie incoming in validMovies)
-                    {
-                        decimal percentCompletion = (decimal) validMovies.IndexOf(incoming) / validMovies.Count;
-                        await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
-
-                        // TODO: figure out how to rebuild playlists
-                        Either<BaseError, MediaItemScanResult<PlexMovie>> maybeMovie = await _movieRepository
-                            .GetOrAdd(library, incoming)
-                            .BindT(existing => UpdateStatistics(pathReplacements, existing, incoming, ffprobePath))
-                            .BindT(existing => UpdateMetadata(existing, incoming, library, connection, token))
-                            .BindT(existing => UpdateArtwork(existing, incoming));
-
-                        await maybeMovie.Match(
-                            async result =>
-                            {
-                                if (result.IsAdded)
-                                {
-                                    await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
-                                }
-                                else if (result.IsUpdated)
-                                {
-                                    await _searchIndex.UpdateItems(
-                                        _searchRepository,
-                                        new List<MediaItem> { result.Item });
-                                }
-                            },
-                            error =>
-                            {
-                                _logger.LogWarning(
-                                    "Error processing plex movie at {Key}: {Error}",
-                                    incoming.Key,
-                                    error.Value);
-                                return Task.CompletedTask;
-                            });
-                    }
-
-                    var movieKeys = validMovies.Map(s => s.Key).ToList();
-                    List<int> ids = await _movieRepository.RemoveMissingPlexMovies(library, movieKeys);
-                    await _searchIndex.RemoveItems(ids);
-
-                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+                    await _metadataRepository.UpdatePlexStatistics(existingVersion.Id, incomingVersion);
                 },
                 error =>
                 {
                     _logger.LogWarning(
-                        "Error synchronizing plex library {Path}: {Error}",
-                        library.Name,
+                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                        "Statistics",
+                        localPath,
                         error.Value);
 
                     return Task.CompletedTask;
                 });
-
-            _searchIndex.Commit();
-            return Unit.Default;
         }
 
-        private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateStatistics(
-            List<PlexPathReplacement> pathReplacements,
-            MediaItemScanResult<PlexMovie> result,
-            PlexMovie incoming,
-            string ffprobePath)
-        {
-            PlexMovie existing = result.Item;
-            MediaVersion existingVersion = existing.MediaVersions.Head();
-            MediaVersion incomingVersion = incoming.MediaVersions.Head();
+        return result;
+    }
 
-            foreach (MediaFile incomingFile in incomingVersion.MediaFiles.HeadOrNone())
-            {
-                foreach (MediaFile existingFile in existingVersion.MediaFiles.HeadOrNone())
+    private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateMetadata(
+        MediaItemScanResult<PlexMovie> result,
+        PlexMovie incoming,
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        PlexMovie existing = result.Item;
+        MovieMetadata existingMetadata = existing.MovieMetadata.Head();
+
+        if (result.IsAdded || incoming.MovieMetadata.Head().DateUpdated > existingMetadata.DateUpdated)
+        {
+            _logger.LogDebug(
+                "Refreshing {Attribute} from {Path}",
+                "Plex Metadata",
+                existing.MediaVersions.Head().MediaFiles.Head().Path);
+
+            Either<BaseError, MovieMetadata> maybeMetadata =
+                await _plexServerApiClient.GetMovieMetadata(
+                    library,
+                    incoming.Key.Split("/").Last(),
+                    connection,
+                    token);
+
+            await maybeMetadata.Match(
+                async fullMetadata =>
                 {
-                    if (incomingFile.Path != existingFile.Path)
+                    if (existingMetadata.MetadataKind != MetadataKind.External)
                     {
-                        _logger.LogDebug(
-                            "Plex movie has moved from {OldPath} to {NewPath}",
-                            existingFile.Path,
-                            incomingFile.Path);
-
-                        existingFile.Path = incomingFile.Path;
-
-                        await _movieRepository.UpdatePath(existingFile.Id, incomingFile.Path);
+                        existingMetadata.MetadataKind = MetadataKind.External;
+                        await _metadataRepository.MarkAsExternal(existingMetadata);
                     }
-                }
-            }
 
-            if (incomingVersion.DateUpdated > existingVersion.DateUpdated || !existingVersion.Streams.Any())
-            {
-                string localPath = _plexPathReplacementService.GetReplacementPlexPath(
-                    pathReplacements,
-                    incoming.MediaVersions.Head().MediaFiles.Head().Path,
-                    false);
-                
-                _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
-                Either<BaseError, bool> refreshResult =
-                    await _localStatisticsProvider.RefreshStatistics(ffprobePath, existing, localPath);
-                
-                await refreshResult.Match(
-                    async _ =>
+                    if (existingMetadata.ContentRating != fullMetadata.ContentRating)
                     {
-                        foreach (MediaItem updated in await _searchRepository.GetItemToIndex(incoming.Id))
-                        {
-                            await _searchIndex.UpdateItems(
-                                _searchRepository,
-                                new List<MediaItem> { updated });
-                        }
+                        existingMetadata.ContentRating = fullMetadata.ContentRating;
+                        await _metadataRepository.SetContentRating(existingMetadata, fullMetadata.ContentRating);
+                        result.IsUpdated = true;
+                    }
 
-                        await _metadataRepository.UpdatePlexStatistics(existingVersion.Id, incomingVersion);
-                    },
-                    error =>
+                    foreach (Genre genre in existingMetadata.Genres
+                                 .Filter(g => fullMetadata.Genres.All(g2 => g2.Name != g.Name))
+                                 .ToList())
                     {
-                        _logger.LogWarning(
-                            "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                            "Statistics",
-                            localPath,
-                            error.Value);
-
-                        return Task.CompletedTask;
-                    });
-            }
-
-            return result;
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateMetadata(
-            MediaItemScanResult<PlexMovie> result,
-            PlexMovie incoming,
-            PlexLibrary library,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            PlexMovie existing = result.Item;
-            MovieMetadata existingMetadata = existing.MovieMetadata.Head();
-
-            if (result.IsAdded || incoming.MovieMetadata.Head().DateUpdated > existingMetadata.DateUpdated)
-            {
-                _logger.LogDebug(
-                    "Refreshing {Attribute} from {Path}",
-                    "Plex Metadata",
-                    existing.MediaVersions.Head().MediaFiles.Head().Path);
-
-                Either<BaseError, MovieMetadata> maybeMetadata =
-                    await _plexServerApiClient.GetMovieMetadata(
-                        library,
-                        incoming.Key.Split("/").Last(),
-                        connection,
-                        token);
-
-                await maybeMetadata.Match(
-                    async fullMetadata =>
-                    {
-                        if (existingMetadata.MetadataKind != MetadataKind.External)
+                        existingMetadata.Genres.Remove(genre);
+                        if (await _metadataRepository.RemoveGenre(genre))
                         {
-                            existingMetadata.MetadataKind = MetadataKind.External;
-                            await _metadataRepository.MarkAsExternal(existingMetadata);
-                        }
-
-                        if (existingMetadata.ContentRating != fullMetadata.ContentRating)
-                        {
-                            existingMetadata.ContentRating = fullMetadata.ContentRating;
-                            await _metadataRepository.SetContentRating(existingMetadata, fullMetadata.ContentRating);
                             result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Genre genre in existingMetadata.Genres
-                            .Filter(g => fullMetadata.Genres.All(g2 => g2.Name != g.Name))
-                            .ToList())
+                    foreach (Genre genre in fullMetadata.Genres
+                                 .Filter(g => existingMetadata.Genres.All(g2 => g2.Name != g.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Genres.Add(genre);
+                        if (await _movieRepository.AddGenre(existingMetadata, genre))
                         {
-                            existingMetadata.Genres.Remove(genre);
-                            if (await _metadataRepository.RemoveGenre(genre))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Genre genre in fullMetadata.Genres
-                            .Filter(g => existingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                            .ToList())
+                    foreach (Studio studio in existingMetadata.Studios
+                                 .Filter(s => fullMetadata.Studios.All(s2 => s2.Name != s.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Studios.Remove(studio);
+                        if (await _metadataRepository.RemoveStudio(studio))
                         {
-                            existingMetadata.Genres.Add(genre);
-                            if (await _movieRepository.AddGenre(existingMetadata, genre))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Studio studio in existingMetadata.Studios
-                            .Filter(s => fullMetadata.Studios.All(s2 => s2.Name != s.Name))
-                            .ToList())
+                    foreach (Studio studio in fullMetadata.Studios
+                                 .Filter(s => existingMetadata.Studios.All(s2 => s2.Name != s.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Studios.Add(studio);
+                        if (await _movieRepository.AddStudio(existingMetadata, studio))
                         {
-                            existingMetadata.Studios.Remove(studio);
-                            if (await _metadataRepository.RemoveStudio(studio))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Studio studio in fullMetadata.Studios
-                            .Filter(s => existingMetadata.Studios.All(s2 => s2.Name != s.Name))
-                            .ToList())
+                    foreach (Actor actor in existingMetadata.Actors
+                                 .Filter(
+                                     a => fullMetadata.Actors.All(
+                                         a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
+                                 .ToList())
+                    {
+                        existingMetadata.Actors.Remove(actor);
+                        if (await _metadataRepository.RemoveActor(actor))
                         {
-                            existingMetadata.Studios.Add(studio);
-                            if (await _movieRepository.AddStudio(existingMetadata, studio))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Actor actor in existingMetadata.Actors
-                            .Filter(
-                                a => fullMetadata.Actors.All(
-                                    a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
-                            .ToList())
+                    foreach (Actor actor in fullMetadata.Actors
+                                 .Filter(a => existingMetadata.Actors.All(a2 => a2.Name != a.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Actors.Add(actor);
+                        if (await _movieRepository.AddActor(existingMetadata, actor))
                         {
-                            existingMetadata.Actors.Remove(actor);
-                            if (await _metadataRepository.RemoveActor(actor))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Actor actor in fullMetadata.Actors
-                            .Filter(a => existingMetadata.Actors.All(a2 => a2.Name != a.Name))
-                            .ToList())
+                    foreach (Director director in existingMetadata.Directors
+                                 .Filter(g => fullMetadata.Directors.All(g2 => g2.Name != g.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Directors.Remove(director);
+                        if (await _metadataRepository.RemoveDirector(director))
                         {
-                            existingMetadata.Actors.Add(actor);
-                            if (await _movieRepository.AddActor(existingMetadata, actor))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Director director in existingMetadata.Directors
-                            .Filter(g => fullMetadata.Directors.All(g2 => g2.Name != g.Name))
-                            .ToList())
+                    foreach (Director director in fullMetadata.Directors
+                                 .Filter(g => existingMetadata.Directors.All(g2 => g2.Name != g.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Directors.Add(director);
+                        if (await _movieRepository.AddDirector(existingMetadata, director))
                         {
-                            existingMetadata.Directors.Remove(director);
-                            if (await _metadataRepository.RemoveDirector(director))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Director director in fullMetadata.Directors
-                            .Filter(g => existingMetadata.Directors.All(g2 => g2.Name != g.Name))
-                            .ToList())
+                    foreach (Writer writer in existingMetadata.Writers
+                                 .Filter(g => fullMetadata.Writers.All(g2 => g2.Name != g.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Writers.Remove(writer);
+                        if (await _metadataRepository.RemoveWriter(writer))
                         {
-                            existingMetadata.Directors.Add(director);
-                            if (await _movieRepository.AddDirector(existingMetadata, director))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Writer writer in existingMetadata.Writers
-                            .Filter(g => fullMetadata.Writers.All(g2 => g2.Name != g.Name))
-                            .ToList())
+                    foreach (Writer writer in fullMetadata.Writers
+                                 .Filter(g => existingMetadata.Writers.All(g2 => g2.Name != g.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Writers.Add(writer);
+                        if (await _movieRepository.AddWriter(existingMetadata, writer))
                         {
-                            existingMetadata.Writers.Remove(writer);
-                            if (await _metadataRepository.RemoveWriter(writer))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (Writer writer in fullMetadata.Writers
-                            .Filter(g => existingMetadata.Writers.All(g2 => g2.Name != g.Name))
-                            .ToList())
+                    foreach (MetadataGuid guid in existingMetadata.Guids
+                                 .Filter(g => fullMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                                 .ToList())
+                    {
+                        existingMetadata.Guids.Remove(guid);
+                        if (await _metadataRepository.RemoveGuid(guid))
                         {
-                            existingMetadata.Writers.Add(writer);
-                            if (await _movieRepository.AddWriter(existingMetadata, writer))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (MetadataGuid guid in existingMetadata.Guids
-                            .Filter(g => fullMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                            .ToList())
+                    foreach (MetadataGuid guid in fullMetadata.Guids
+                                 .Filter(g => existingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                                 .ToList())
+                    {
+                        existingMetadata.Guids.Add(guid);
+                        if (await _metadataRepository.AddGuid(existingMetadata, guid))
                         {
-                            existingMetadata.Guids.Remove(guid);
-                            if (await _metadataRepository.RemoveGuid(guid))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        foreach (MetadataGuid guid in fullMetadata.Guids
-                            .Filter(g => existingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                            .ToList())
+                    if (fullMetadata.SortTitle != existingMetadata.SortTitle)
+                    {
+                        existingMetadata.SortTitle = fullMetadata.SortTitle;
+                        if (await _movieRepository.UpdateSortTitle(existingMetadata))
                         {
-                            existingMetadata.Guids.Add(guid);
-                            if (await _metadataRepository.AddGuid(existingMetadata, guid))
-                            {
-                                result.IsUpdated = true;
-                            }
+                            result.IsUpdated = true;
                         }
+                    }
 
-                        if (fullMetadata.SortTitle != existingMetadata.SortTitle)
-                        {
-                            existingMetadata.SortTitle = fullMetadata.SortTitle;
-                            if (await _movieRepository.UpdateSortTitle(existingMetadata))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
+                    if (result.IsUpdated)
+                    {
+                        await _metadataRepository.MarkAsUpdated(existingMetadata, fullMetadata.DateUpdated);
+                    }
+                },
+                _ => Task.CompletedTask);
 
-                        if (result.IsUpdated)
-                        {
-                            await _metadataRepository.MarkAsUpdated(existingMetadata, fullMetadata.DateUpdated);
-                        }
-                    },
-                    _ => Task.CompletedTask);
-
-                // TODO: update other metadata?
-            }
-
-            return result;
+            // TODO: update other metadata?
         }
 
-        private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateArtwork(
-            MediaItemScanResult<PlexMovie> result,
-            PlexMovie incoming)
-        {
-            PlexMovie existing = result.Item;
-            MovieMetadata existingMetadata = existing.MovieMetadata.Head();
-            MovieMetadata incomingMetadata = incoming.MovieMetadata.Head();
-
-            if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
-            {
-                await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
-                await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.FanArt);
-                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
-            }
-
-            return result;
-        }
+        return result;
     }
-}
+
+    private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> UpdateArtwork(
+        MediaItemScanResult<PlexMovie> result,
+        PlexMovie incoming)
+    {
+        PlexMovie existing = result.Item;
+        MovieMetadata existingMetadata = existing.MovieMetadata.Head();
+        MovieMetadata incomingMetadata = incoming.MovieMetadata.Head();
+
+        if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
+        {
+            await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
+            await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.FanArt);
+            await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Plex/PlexPathReplacementService.cs b/ErsatzTV.Core/Plex/PlexPathReplacementService.cs
index ac3cd6ce4..9dbce8c95 100644
--- a/ErsatzTV.Core/Plex/PlexPathReplacementService.cs
+++ b/ErsatzTV.Core/Plex/PlexPathReplacementService.cs
@@ -1,79 +1,74 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Runtime;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Core.Plex
+namespace ErsatzTV.Core.Plex;
+
+public class PlexPathReplacementService : IPlexPathReplacementService
 {
-    public class PlexPathReplacementService : IPlexPathReplacementService
+    private readonly ILogger<PlexPathReplacementService> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IRuntimeInfo _runtimeInfo;
+
+    public PlexPathReplacementService(
+        IMediaSourceRepository mediaSourceRepository,
+        IRuntimeInfo runtimeInfo,
+        ILogger<PlexPathReplacementService> logger)
     {
-        private readonly ILogger<PlexPathReplacementService> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IRuntimeInfo _runtimeInfo;
-
-        public PlexPathReplacementService(
-            IMediaSourceRepository mediaSourceRepository,
-            IRuntimeInfo runtimeInfo,
-            ILogger<PlexPathReplacementService> logger)
-        {
-            _mediaSourceRepository = mediaSourceRepository;
-            _runtimeInfo = runtimeInfo;
-            _logger = logger;
-        }
-
-        public async Task<string> GetReplacementPlexPath(int libraryPathId, string path)
-        {
-            List<PlexPathReplacement> replacements =
-                await _mediaSourceRepository.GetPlexPathReplacementsByLibraryId(libraryPathId);
-
-            return GetReplacementPlexPath(replacements, path);
-        }
-
-        public string GetReplacementPlexPath(List<PlexPathReplacement> pathReplacements, string path, bool log = true)
-        {
-            Option<PlexPathReplacement> maybeReplacement = pathReplacements
-                .SingleOrDefault(
-                    r =>
-                    {
-                        string separatorChar = IsWindows(r.PlexMediaSource) ? @"\" : @"/";
-                        string prefix = r.PlexPath.EndsWith(separatorChar) ? r.PlexPath : r.PlexPath + separatorChar;
-                        return path.StartsWith(prefix);
-                    });
-
-            return maybeReplacement.Match(
-                replacement =>
-                {
-                    string finalPath = path.Replace(replacement.PlexPath, replacement.LocalPath);
-                    if (IsWindows(replacement.PlexMediaSource) && !_runtimeInfo.IsOSPlatform(OSPlatform.Windows))
-                    {
-                        finalPath = finalPath.Replace(@"\", @"/");
-                    }
-                    else if (!IsWindows(replacement.PlexMediaSource) && _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
-                    {
-                        finalPath = finalPath.Replace(@"/", @"\");
-                    }
-
-                    if (log)
-                    {
-                        _logger.LogInformation(
-                            "Replacing plex path {PlexPath} with {LocalPath} resulting in {FinalPath}",
-                            replacement.PlexPath,
-                            replacement.LocalPath,
-                            finalPath);
-                    }
-
-                    return finalPath;
-                },
-                () => path);
-        }
-
-        private static bool IsWindows(PlexMediaSource plexMediaSource) =>
-            plexMediaSource.Platform.ToLowerInvariant() == "windows";
+        _mediaSourceRepository = mediaSourceRepository;
+        _runtimeInfo = runtimeInfo;
+        _logger = logger;
     }
-}
+
+    public async Task<string> GetReplacementPlexPath(int libraryPathId, string path)
+    {
+        List<PlexPathReplacement> replacements =
+            await _mediaSourceRepository.GetPlexPathReplacementsByLibraryId(libraryPathId);
+
+        return GetReplacementPlexPath(replacements, path);
+    }
+
+    public string GetReplacementPlexPath(List<PlexPathReplacement> pathReplacements, string path, bool log = true)
+    {
+        Option<PlexPathReplacement> maybeReplacement = pathReplacements
+            .SingleOrDefault(
+                r =>
+                {
+                    string separatorChar = IsWindows(r.PlexMediaSource) ? @"\" : @"/";
+                    string prefix = r.PlexPath.EndsWith(separatorChar) ? r.PlexPath : r.PlexPath + separatorChar;
+                    return path.StartsWith(prefix);
+                });
+
+        return maybeReplacement.Match(
+            replacement =>
+            {
+                string finalPath = path.Replace(replacement.PlexPath, replacement.LocalPath);
+                if (IsWindows(replacement.PlexMediaSource) && !_runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                {
+                    finalPath = finalPath.Replace(@"\", @"/");
+                }
+                else if (!IsWindows(replacement.PlexMediaSource) && _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
+                {
+                    finalPath = finalPath.Replace(@"/", @"\");
+                }
+
+                if (log)
+                {
+                    _logger.LogInformation(
+                        "Replacing plex path {PlexPath} with {LocalPath} resulting in {FinalPath}",
+                        replacement.PlexPath,
+                        replacement.LocalPath,
+                        finalPath);
+                }
+
+                return finalPath;
+            },
+            () => path);
+    }
+
+    private static bool IsWindows(PlexMediaSource plexMediaSource) =>
+        plexMediaSource.Platform.ToLowerInvariant() == "windows";
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Plex/PlexServerAuthToken.cs b/ErsatzTV.Core/Plex/PlexServerAuthToken.cs
index 4f16e6223..aa9169fbf 100644
--- a/ErsatzTV.Core/Plex/PlexServerAuthToken.cs
+++ b/ErsatzTV.Core/Plex/PlexServerAuthToken.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Core.Plex
-{
-    public record PlexServerAuthToken(string ClientIdentifier, string AuthToken);
-}
+namespace ErsatzTV.Core.Plex;
+
+public record PlexServerAuthToken(string ClientIdentifier, string AuthToken);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs b/ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs
index e27b0caed..0ea8d68e0 100644
--- a/ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs
+++ b/ErsatzTV.Core/Plex/PlexTelevisionLibraryScanner.cs
@@ -1,633 +1,625 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using MediatR;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Core.Plex
+namespace ErsatzTV.Core.Plex;
+
+public class PlexTelevisionLibraryScanner : PlexLibraryScanner, IPlexTelevisionLibraryScanner
 {
-    public class PlexTelevisionLibraryScanner : PlexLibraryScanner, IPlexTelevisionLibraryScanner
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILocalStatisticsProvider _localStatisticsProvider;
+    private readonly ILogger<PlexTelevisionLibraryScanner> _logger;
+    private readonly IMediaSourceRepository _mediaSourceRepository;
+    private readonly IMediator _mediator;
+    private readonly IMetadataRepository _metadataRepository;
+    private readonly IPlexPathReplacementService _plexPathReplacementService;
+    private readonly IPlexServerApiClient _plexServerApiClient;
+    private readonly ISearchIndex _searchIndex;
+    private readonly ISearchRepository _searchRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public PlexTelevisionLibraryScanner(
+        IPlexServerApiClient plexServerApiClient,
+        ITelevisionRepository televisionRepository,
+        IMetadataRepository metadataRepository,
+        ISearchIndex searchIndex,
+        ISearchRepository searchRepository,
+        IMediator mediator,
+        IMediaSourceRepository mediaSourceRepository,
+        IPlexPathReplacementService plexPathReplacementService,
+        ILocalFileSystem localFileSystem,
+        ILocalStatisticsProvider localStatisticsProvider,
+        ILogger<PlexTelevisionLibraryScanner> logger)
+        : base(metadataRepository, logger)
     {
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILocalStatisticsProvider _localStatisticsProvider;
-        private readonly ILogger<PlexTelevisionLibraryScanner> _logger;
-        private readonly IMediaSourceRepository _mediaSourceRepository;
-        private readonly IMediator _mediator;
-        private readonly IMetadataRepository _metadataRepository;
-        private readonly IPlexPathReplacementService _plexPathReplacementService;
-        private readonly IPlexServerApiClient _plexServerApiClient;
-        private readonly ISearchIndex _searchIndex;
-        private readonly ISearchRepository _searchRepository;
-        private readonly ITelevisionRepository _televisionRepository;
+        _plexServerApiClient = plexServerApiClient;
+        _televisionRepository = televisionRepository;
+        _metadataRepository = metadataRepository;
+        _searchIndex = searchIndex;
+        _searchRepository = searchRepository;
+        _mediator = mediator;
+        _mediaSourceRepository = mediaSourceRepository;
+        _plexPathReplacementService = plexPathReplacementService;
+        _localFileSystem = localFileSystem;
+        _localStatisticsProvider = localStatisticsProvider;
+        _logger = logger;
+    }
 
-        public PlexTelevisionLibraryScanner(
-            IPlexServerApiClient plexServerApiClient,
-            ITelevisionRepository televisionRepository,
-            IMetadataRepository metadataRepository,
-            ISearchIndex searchIndex,
-            ISearchRepository searchRepository,
-            IMediator mediator,
-            IMediaSourceRepository mediaSourceRepository,
-            IPlexPathReplacementService plexPathReplacementService,
-            ILocalFileSystem localFileSystem,
-            ILocalStatisticsProvider localStatisticsProvider,
-            ILogger<PlexTelevisionLibraryScanner> logger)
-            : base(metadataRepository, logger)
-        {
-            _plexServerApiClient = plexServerApiClient;
-            _televisionRepository = televisionRepository;
-            _metadataRepository = metadataRepository;
-            _searchIndex = searchIndex;
-            _searchRepository = searchRepository;
-            _mediator = mediator;
-            _mediaSourceRepository = mediaSourceRepository;
-            _plexPathReplacementService = plexPathReplacementService;
-            _localFileSystem = localFileSystem;
-            _localStatisticsProvider = localStatisticsProvider;
-            _logger = logger;
-        }
+    public async Task<Either<BaseError, Unit>> ScanLibrary(
+        PlexConnection connection,
+        PlexServerAuthToken token,
+        PlexLibrary library,
+        string ffprobePath)
+    {
+        List<PlexPathReplacement> pathReplacements = await _mediaSourceRepository
+            .GetPlexPathReplacements(library.MediaSourceId);
 
-        public async Task<Either<BaseError, Unit>> ScanLibrary(
-            PlexConnection connection,
-            PlexServerAuthToken token,
-            PlexLibrary library,
-            string ffprobePath)
-        {
-            List<PlexPathReplacement> pathReplacements = await _mediaSourceRepository
-                .GetPlexPathReplacements(library.MediaSourceId);
+        Either<BaseError, List<PlexShow>> entries = await _plexServerApiClient.GetShowLibraryContents(
+            library,
+            connection,
+            token);
 
-            Either<BaseError, List<PlexShow>> entries = await _plexServerApiClient.GetShowLibraryContents(
-                library,
-                connection,
-                token);
-
-            return await entries.Match<Task<Either<BaseError, Unit>>>(
-                async showEntries =>
-                {
-                    foreach (PlexShow incoming in showEntries)
-                    {
-                        decimal percentCompletion = (decimal) showEntries.IndexOf(incoming) / showEntries.Count;
-                        await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
-
-                        // TODO: figure out how to rebuild playlists
-                        Either<BaseError, MediaItemScanResult<PlexShow>> maybeShow = await _televisionRepository
-                            .GetOrAddPlexShow(library, incoming)
-                            .BindT(existing => UpdateMetadata(existing, incoming, library, connection, token))
-                            .BindT(existing => UpdateArtwork(existing, incoming));
-
-                        await maybeShow.Match(
-                            async result =>
-                            {
-                                await ScanSeasons(library, pathReplacements, result.Item, connection, token, ffprobePath);
-
-                                if (result.IsAdded)
-                                {
-                                    await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
-                                }
-                                else if (result.IsUpdated)
-                                {
-                                    await _searchIndex.UpdateItems(
-                                        _searchRepository,
-                                        new List<MediaItem> { result.Item });
-                                }
-                            },
-                            error =>
-                            {
-                                _logger.LogWarning(
-                                    "Error processing plex show at {Key}: {Error}",
-                                    incoming.Key,
-                                    error.Value);
-                                return Task.CompletedTask;
-                            });
-                    }
-
-                    var showKeys = showEntries.Map(s => s.Key).ToList();
-                    List<int> ids =
-                        await _televisionRepository.RemoveMissingPlexShows(library, showKeys);
-                    await _searchIndex.RemoveItems(ids);
-
-                    await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
-
-                    _searchIndex.Commit();
-                    return Unit.Default;
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Error synchronizing plex library {Path}: {Error}",
-                        library.Name,
-                        error.Value);
-
-                    return Left<BaseError, Unit>(error).AsTask();
-                });
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> UpdateMetadata(
-            MediaItemScanResult<PlexShow> result,
-            PlexShow incoming,
-            PlexLibrary library,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            PlexShow existing = result.Item;
-            ShowMetadata existingMetadata = existing.ShowMetadata.Head();
-
-            if (result.IsAdded || incoming.ShowMetadata.Head().DateUpdated > existingMetadata.DateUpdated)
+        return await entries.Match<Task<Either<BaseError, Unit>>>(
+            async showEntries =>
             {
-                Either<BaseError, ShowMetadata> maybeMetadata =
-                    await _plexServerApiClient.GetShowMetadata(
-                        library,
-                        incoming.Key.Replace("/children", string.Empty).Split("/").Last(),
-                        connection,
-                        token);
-
-                await maybeMetadata.Match(
-                    async fullMetadata =>
-                    {
-                        if (existingMetadata.MetadataKind != MetadataKind.External)
-                        {
-                            existingMetadata.MetadataKind = MetadataKind.External;
-                            await _metadataRepository.MarkAsExternal(existingMetadata);
-                        }
-
-                        if (existingMetadata.ContentRating != fullMetadata.ContentRating)
-                        {
-                            existingMetadata.ContentRating = fullMetadata.ContentRating;
-                            await _metadataRepository.SetContentRating(existingMetadata, fullMetadata.ContentRating);
-                            result.IsUpdated = true;
-                        }
-
-                        foreach (Genre genre in existingMetadata.Genres
-                            .Filter(g => fullMetadata.Genres.All(g2 => g2.Name != g.Name))
-                            .ToList())
-                        {
-                            existingMetadata.Genres.Remove(genre);
-                            if (await _metadataRepository.RemoveGenre(genre))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-
-                        foreach (Genre genre in fullMetadata.Genres
-                            .Filter(g => existingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                            .ToList())
-                        {
-                            existingMetadata.Genres.Add(genre);
-                            if (await _televisionRepository.AddGenre(existingMetadata, genre))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-
-                        foreach (Studio studio in existingMetadata.Studios
-                            .Filter(s => fullMetadata.Studios.All(s2 => s2.Name != s.Name))
-                            .ToList())
-                        {
-                            existingMetadata.Studios.Remove(studio);
-                            if (await _metadataRepository.RemoveStudio(studio))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-
-                        foreach (Studio studio in fullMetadata.Studios
-                            .Filter(s => existingMetadata.Studios.All(s2 => s2.Name != s.Name))
-                            .ToList())
-                        {
-                            existingMetadata.Studios.Add(studio);
-                            if (await _televisionRepository.AddStudio(existingMetadata, studio))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-
-                        foreach (Actor actor in existingMetadata.Actors
-                            .Filter(
-                                a => fullMetadata.Actors.All(
-                                    a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
-                            .ToList())
-                        {
-                            existingMetadata.Actors.Remove(actor);
-                            if (await _metadataRepository.RemoveActor(actor))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-
-                        foreach (Actor actor in fullMetadata.Actors
-                            .Filter(a => existingMetadata.Actors.All(a2 => a2.Name != a.Name))
-                            .ToList())
-                        {
-                            existingMetadata.Actors.Add(actor);
-                            if (await _televisionRepository.AddActor(existingMetadata, actor))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-
-                        foreach (MetadataGuid guid in existingMetadata.Guids
-                            .Filter(g => fullMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                            .ToList())
-                        {
-                            existingMetadata.Guids.Remove(guid);
-                            if (await _metadataRepository.RemoveGuid(guid))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-
-                        foreach (MetadataGuid guid in fullMetadata.Guids
-                            .Filter(g => existingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                            .ToList())
-                        {
-                            existingMetadata.Guids.Add(guid);
-                            if (await _metadataRepository.AddGuid(existingMetadata, guid))
-                            {
-                                result.IsUpdated = true;
-                            }
-                        }
-
-                        if (result.IsUpdated)
-                        {
-                            await _metadataRepository.MarkAsUpdated(existingMetadata, fullMetadata.DateUpdated);
-                        }
-                    },
-                    _ => Task.CompletedTask);
-            }
-
-            return result;
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> UpdateArtwork(
-            MediaItemScanResult<PlexShow> result,
-            PlexShow incoming)
-        {
-            PlexShow existing = result.Item;
-            ShowMetadata existingMetadata = existing.ShowMetadata.Head();
-            ShowMetadata incomingMetadata = incoming.ShowMetadata.Head();
-
-            if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
-            {
-                await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
-                await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.FanArt);
-                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
-            }
-
-            return result;
-        }
-
-        private async Task<Either<BaseError, Unit>> ScanSeasons(
-            PlexLibrary library,
-            List<PlexPathReplacement> pathReplacements,
-            PlexShow show,
-            PlexConnection connection,
-            PlexServerAuthToken token,
-            string ffprobePath)
-        {
-            Either<BaseError, List<PlexSeason>> entries = await _plexServerApiClient.GetShowSeasons(
-                library,
-                show,
-                connection,
-                token);
-
-            return await entries.Match<Task<Either<BaseError, Unit>>>(
-                async seasonEntries =>
+                foreach (PlexShow incoming in showEntries)
                 {
-                    foreach (PlexSeason incoming in seasonEntries)
-                    {
-                        incoming.ShowId = show.Id;
+                    decimal percentCompletion = (decimal) showEntries.IndexOf(incoming) / showEntries.Count;
+                    await _mediator.Publish(new LibraryScanProgress(library.Id, percentCompletion));
 
-                        // TODO: figure out how to rebuild playlists
-                        Either<BaseError, PlexSeason> maybeSeason = await _televisionRepository
-                            .GetOrAddPlexSeason(library, incoming)
-                            .BindT(existing => UpdateMetadataAndArtwork(existing, incoming));
+                    // TODO: figure out how to rebuild playlists
+                    Either<BaseError, MediaItemScanResult<PlexShow>> maybeShow = await _televisionRepository
+                        .GetOrAddPlexShow(library, incoming)
+                        .BindT(existing => UpdateMetadata(existing, incoming, library, connection, token))
+                        .BindT(existing => UpdateArtwork(existing, incoming));
 
-                        await maybeSeason.Match(
-                            async season =>
+                    await maybeShow.Match(
+                        async result =>
+                        {
+                            await ScanSeasons(library, pathReplacements, result.Item, connection, token, ffprobePath);
+
+                            if (result.IsAdded)
                             {
-                                await ScanEpisodes(
-                                    library,
-                                    pathReplacements,
-                                    season,
-                                    connection,
-                                    token,
-                                    ffprobePath);
-
-                                season.Show = show;
-                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { season });
-                            },
-                            error =>
+                                await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { result.Item });
+                            }
+                            else if (result.IsUpdated)
                             {
-                                _logger.LogWarning(
-                                    "Error processing plex show at {Key}: {Error}",
-                                    incoming.Key,
-                                    error.Value);
-                                return Task.CompletedTask;
-                            });
-                    }
-
-                    var seasonKeys = seasonEntries.Map(s => s.Key).ToList();
-                    await _televisionRepository.RemoveMissingPlexSeasons(show.Key, seasonKeys);
-
-                    return Unit.Default;
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Error synchronizing plex library {Path}: {Error}",
-                        library.Name,
-                        error.Value);
-
-                    return Left<BaseError, Unit>(error).AsTask();
-                });
-        }
-
-        private async Task<Either<BaseError, PlexSeason>> UpdateMetadataAndArtwork(
-            PlexSeason existing,
-            PlexSeason incoming)
-        {
-            SeasonMetadata existingMetadata = existing.SeasonMetadata.Head();
-            SeasonMetadata incomingMetadata = incoming.SeasonMetadata.Head();
-
-            if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
-            {
-                foreach (MetadataGuid guid in existingMetadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    existingMetadata.Guids.Remove(guid);
-                    await _metadataRepository.RemoveGuid(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => existingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    existingMetadata.Guids.Add(guid);
-                    await _metadataRepository.AddGuid(existingMetadata, guid);
-                }
-
-                await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
-                await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
-            }
-
-            return existing;
-        }
-
-        private async Task<Either<BaseError, Unit>> ScanEpisodes(
-            PlexLibrary library,
-            List<PlexPathReplacement> pathReplacements,
-            PlexSeason season,
-            PlexConnection connection,
-            PlexServerAuthToken token,
-            string ffprobePath)
-        {
-            Either<BaseError, List<PlexEpisode>> entries = await _plexServerApiClient.GetSeasonEpisodes(
-                library,
-                season,
-                connection,
-                token);
-
-            return await entries.Match<Task<Either<BaseError, Unit>>>(
-                async episodeEntries =>
-                {
-                    var validEpisodes = new List<PlexEpisode>();
-                    foreach (PlexEpisode episode in episodeEntries)
-                    {
-                        string localPath = _plexPathReplacementService.GetReplacementPlexPath(
-                            pathReplacements,
-                            episode.MediaVersions.Head().MediaFiles.Head().Path,
-                            false);
-
-                        if (!_localFileSystem.FileExists(localPath))
+                                await _searchIndex.UpdateItems(
+                                    _searchRepository,
+                                    new List<MediaItem> { result.Item });
+                            }
+                        },
+                        error =>
                         {
                             _logger.LogWarning(
-                                "Skipping plex episode that does not exist at {Path}",
-                                localPath);
-                        }
-                        else
-                        {
-                            validEpisodes.Add(episode);
-                        }
-                    }
+                                "Error processing plex show at {Key}: {Error}",
+                                incoming.Key,
+                                error.Value);
+                            return Task.CompletedTask;
+                        });
+                }
 
-                    foreach (PlexEpisode incoming in validEpisodes)
+                var showKeys = showEntries.Map(s => s.Key).ToList();
+                List<int> ids =
+                    await _televisionRepository.RemoveMissingPlexShows(library, showKeys);
+                await _searchIndex.RemoveItems(ids);
+
+                await _mediator.Publish(new LibraryScanProgress(library.Id, 0));
+
+                _searchIndex.Commit();
+                return Unit.Default;
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing plex library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
+
+                return Left<BaseError, Unit>(error).AsTask();
+            });
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> UpdateMetadata(
+        MediaItemScanResult<PlexShow> result,
+        PlexShow incoming,
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        PlexShow existing = result.Item;
+        ShowMetadata existingMetadata = existing.ShowMetadata.Head();
+
+        if (result.IsAdded || incoming.ShowMetadata.Head().DateUpdated > existingMetadata.DateUpdated)
+        {
+            Either<BaseError, ShowMetadata> maybeMetadata =
+                await _plexServerApiClient.GetShowMetadata(
+                    library,
+                    incoming.Key.Replace("/children", string.Empty).Split("/").Last(),
+                    connection,
+                    token);
+
+            await maybeMetadata.Match(
+                async fullMetadata =>
+                {
+                    if (existingMetadata.MetadataKind != MetadataKind.External)
                     {
-                        incoming.SeasonId = season.Id;
-
-                        // TODO: figure out how to rebuild playlists
-                        Either<BaseError, PlexEpisode> maybeEpisode = await _televisionRepository
-                            .GetOrAddPlexEpisode(library, incoming)
-                            .BindT(existing => UpdateMetadata(existing, incoming))
-                            .BindT(
-                                existing => UpdateStatistics(
-                                    pathReplacements,
-                                    existing,
-                                    incoming,
-                                    library,
-                                    connection,
-                                    token,
-                                    ffprobePath))
-                            .BindT(existing => UpdateArtwork(existing, incoming));
-
-                        await maybeEpisode.Match(
-                            async episode =>
-                            {
-                                await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { episode });
-                            },
-                            error =>
-                            {
-                                _logger.LogWarning(
-                                    "Error processing plex episode at {Key}: {Error}",
-                                    incoming.Key,
-                                    error.Value);
-                                return Task.CompletedTask;
-                            });
+                        existingMetadata.MetadataKind = MetadataKind.External;
+                        await _metadataRepository.MarkAsExternal(existingMetadata);
                     }
 
-                    var episodeKeys = validEpisodes.Map(s => s.Key).ToList();
-                    List<int> ids = await _televisionRepository.RemoveMissingPlexEpisodes(season.Key, episodeKeys);
-                    await _searchIndex.RemoveItems(ids);
-                    _searchIndex.Commit();
+                    if (existingMetadata.ContentRating != fullMetadata.ContentRating)
+                    {
+                        existingMetadata.ContentRating = fullMetadata.ContentRating;
+                        await _metadataRepository.SetContentRating(existingMetadata, fullMetadata.ContentRating);
+                        result.IsUpdated = true;
+                    }
 
-                    return Unit.Default;
+                    foreach (Genre genre in existingMetadata.Genres
+                                 .Filter(g => fullMetadata.Genres.All(g2 => g2.Name != g.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Genres.Remove(genre);
+                        if (await _metadataRepository.RemoveGenre(genre))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+
+                    foreach (Genre genre in fullMetadata.Genres
+                                 .Filter(g => existingMetadata.Genres.All(g2 => g2.Name != g.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Genres.Add(genre);
+                        if (await _televisionRepository.AddGenre(existingMetadata, genre))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+
+                    foreach (Studio studio in existingMetadata.Studios
+                                 .Filter(s => fullMetadata.Studios.All(s2 => s2.Name != s.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Studios.Remove(studio);
+                        if (await _metadataRepository.RemoveStudio(studio))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+
+                    foreach (Studio studio in fullMetadata.Studios
+                                 .Filter(s => existingMetadata.Studios.All(s2 => s2.Name != s.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Studios.Add(studio);
+                        if (await _televisionRepository.AddStudio(existingMetadata, studio))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+
+                    foreach (Actor actor in existingMetadata.Actors
+                                 .Filter(
+                                     a => fullMetadata.Actors.All(
+                                         a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
+                                 .ToList())
+                    {
+                        existingMetadata.Actors.Remove(actor);
+                        if (await _metadataRepository.RemoveActor(actor))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+
+                    foreach (Actor actor in fullMetadata.Actors
+                                 .Filter(a => existingMetadata.Actors.All(a2 => a2.Name != a.Name))
+                                 .ToList())
+                    {
+                        existingMetadata.Actors.Add(actor);
+                        if (await _televisionRepository.AddActor(existingMetadata, actor))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+
+                    foreach (MetadataGuid guid in existingMetadata.Guids
+                                 .Filter(g => fullMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                                 .ToList())
+                    {
+                        existingMetadata.Guids.Remove(guid);
+                        if (await _metadataRepository.RemoveGuid(guid))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+
+                    foreach (MetadataGuid guid in fullMetadata.Guids
+                                 .Filter(g => existingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                                 .ToList())
+                    {
+                        existingMetadata.Guids.Add(guid);
+                        if (await _metadataRepository.AddGuid(existingMetadata, guid))
+                        {
+                            result.IsUpdated = true;
+                        }
+                    }
+
+                    if (result.IsUpdated)
+                    {
+                        await _metadataRepository.MarkAsUpdated(existingMetadata, fullMetadata.DateUpdated);
+                    }
+                },
+                _ => Task.CompletedTask);
+        }
+
+        return result;
+    }
+
+    private async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> UpdateArtwork(
+        MediaItemScanResult<PlexShow> result,
+        PlexShow incoming)
+    {
+        PlexShow existing = result.Item;
+        ShowMetadata existingMetadata = existing.ShowMetadata.Head();
+        ShowMetadata incomingMetadata = incoming.ShowMetadata.Head();
+
+        if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
+        {
+            await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
+            await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.FanArt);
+            await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
+        }
+
+        return result;
+    }
+
+    private async Task<Either<BaseError, Unit>> ScanSeasons(
+        PlexLibrary library,
+        List<PlexPathReplacement> pathReplacements,
+        PlexShow show,
+        PlexConnection connection,
+        PlexServerAuthToken token,
+        string ffprobePath)
+    {
+        Either<BaseError, List<PlexSeason>> entries = await _plexServerApiClient.GetShowSeasons(
+            library,
+            show,
+            connection,
+            token);
+
+        return await entries.Match<Task<Either<BaseError, Unit>>>(
+            async seasonEntries =>
+            {
+                foreach (PlexSeason incoming in seasonEntries)
+                {
+                    incoming.ShowId = show.Id;
+
+                    // TODO: figure out how to rebuild playlists
+                    Either<BaseError, PlexSeason> maybeSeason = await _televisionRepository
+                        .GetOrAddPlexSeason(library, incoming)
+                        .BindT(existing => UpdateMetadataAndArtwork(existing, incoming));
+
+                    await maybeSeason.Match(
+                        async season =>
+                        {
+                            await ScanEpisodes(
+                                library,
+                                pathReplacements,
+                                season,
+                                connection,
+                                token,
+                                ffprobePath);
+
+                            season.Show = show;
+                            await _searchIndex.AddItems(_searchRepository, new List<MediaItem> { season });
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning(
+                                "Error processing plex show at {Key}: {Error}",
+                                incoming.Key,
+                                error.Value);
+                            return Task.CompletedTask;
+                        });
+                }
+
+                var seasonKeys = seasonEntries.Map(s => s.Key).ToList();
+                await _televisionRepository.RemoveMissingPlexSeasons(show.Key, seasonKeys);
+
+                return Unit.Default;
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing plex library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
+
+                return Left<BaseError, Unit>(error).AsTask();
+            });
+    }
+
+    private async Task<Either<BaseError, PlexSeason>> UpdateMetadataAndArtwork(
+        PlexSeason existing,
+        PlexSeason incoming)
+    {
+        SeasonMetadata existingMetadata = existing.SeasonMetadata.Head();
+        SeasonMetadata incomingMetadata = incoming.SeasonMetadata.Head();
+
+        if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
+        {
+            foreach (MetadataGuid guid in existingMetadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                existingMetadata.Guids.Remove(guid);
+                await _metadataRepository.RemoveGuid(guid);
+            }
+
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => existingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                existingMetadata.Guids.Add(guid);
+                await _metadataRepository.AddGuid(existingMetadata, guid);
+            }
+
+            await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Poster);
+            await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
+        }
+
+        return existing;
+    }
+
+    private async Task<Either<BaseError, Unit>> ScanEpisodes(
+        PlexLibrary library,
+        List<PlexPathReplacement> pathReplacements,
+        PlexSeason season,
+        PlexConnection connection,
+        PlexServerAuthToken token,
+        string ffprobePath)
+    {
+        Either<BaseError, List<PlexEpisode>> entries = await _plexServerApiClient.GetSeasonEpisodes(
+            library,
+            season,
+            connection,
+            token);
+
+        return await entries.Match<Task<Either<BaseError, Unit>>>(
+            async episodeEntries =>
+            {
+                var validEpisodes = new List<PlexEpisode>();
+                foreach (PlexEpisode episode in episodeEntries)
+                {
+                    string localPath = _plexPathReplacementService.GetReplacementPlexPath(
+                        pathReplacements,
+                        episode.MediaVersions.Head().MediaFiles.Head().Path,
+                        false);
+
+                    if (!_localFileSystem.FileExists(localPath))
+                    {
+                        _logger.LogWarning(
+                            "Skipping plex episode that does not exist at {Path}",
+                            localPath);
+                    }
+                    else
+                    {
+                        validEpisodes.Add(episode);
+                    }
+                }
+
+                foreach (PlexEpisode incoming in validEpisodes)
+                {
+                    incoming.SeasonId = season.Id;
+
+                    // TODO: figure out how to rebuild playlists
+                    Either<BaseError, PlexEpisode> maybeEpisode = await _televisionRepository
+                        .GetOrAddPlexEpisode(library, incoming)
+                        .BindT(existing => UpdateMetadata(existing, incoming))
+                        .BindT(
+                            existing => UpdateStatistics(
+                                pathReplacements,
+                                existing,
+                                incoming,
+                                library,
+                                connection,
+                                token,
+                                ffprobePath))
+                        .BindT(existing => UpdateArtwork(existing, incoming));
+
+                    await maybeEpisode.Match(
+                        async episode =>
+                        {
+                            await _searchIndex.UpdateItems(_searchRepository, new List<MediaItem> { episode });
+                        },
+                        error =>
+                        {
+                            _logger.LogWarning(
+                                "Error processing plex episode at {Key}: {Error}",
+                                incoming.Key,
+                                error.Value);
+                            return Task.CompletedTask;
+                        });
+                }
+
+                var episodeKeys = validEpisodes.Map(s => s.Key).ToList();
+                List<int> ids = await _televisionRepository.RemoveMissingPlexEpisodes(season.Key, episodeKeys);
+                await _searchIndex.RemoveItems(ids);
+                _searchIndex.Commit();
+
+                return Unit.Default;
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Error synchronizing plex library {Path}: {Error}",
+                    library.Name,
+                    error.Value);
+
+                return Left<BaseError, Unit>(error).AsTask();
+            });
+    }
+
+    private async Task<Either<BaseError, PlexEpisode>> UpdateMetadata(PlexEpisode existing, PlexEpisode incoming)
+    {
+        var toUpdate = existing.EpisodeMetadata
+            .Where(em => incoming.EpisodeMetadata.Any(em2 => em2.EpisodeNumber == em.EpisodeNumber))
+            .ToList();
+        var toRemove = existing.EpisodeMetadata.Except(toUpdate).ToList();
+        var toAdd = incoming.EpisodeMetadata
+            .Where(em => existing.EpisodeMetadata.All(em2 => em2.EpisodeNumber != em.EpisodeNumber))
+            .ToList();
+
+        foreach (EpisodeMetadata metadata in toRemove)
+        {
+            await _televisionRepository.RemoveMetadata(existing, metadata);
+        }
+
+        foreach (EpisodeMetadata metadata in toAdd)
+        {
+            metadata.EpisodeId = existing.Id;
+            metadata.Episode = existing;
+            existing.EpisodeMetadata.Add(metadata);
+
+            await _metadataRepository.Add(metadata);
+        }
+
+        // TODO: update existing metadata
+
+        return existing;
+    }
+
+    private async Task<Either<BaseError, PlexEpisode>> UpdateStatistics(
+        List<PlexPathReplacement> pathReplacements,
+        PlexEpisode existing,
+        PlexEpisode incoming,
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token,
+        string ffprobePath)
+    {
+        MediaVersion existingVersion = existing.MediaVersions.Head();
+        MediaVersion incomingVersion = incoming.MediaVersions.Head();
+            
+        foreach (MediaFile incomingFile in incomingVersion.MediaFiles.HeadOrNone())
+        {
+            foreach (MediaFile existingFile in existingVersion.MediaFiles.HeadOrNone())
+            {
+                if (incomingFile.Path != existingFile.Path)
+                {
+                    _logger.LogDebug(
+                        "Plex episode has moved from {OldPath} to {NewPath}",
+                        existingFile.Path,
+                        incomingFile.Path);
+
+                    existingFile.Path = incomingFile.Path;
+
+                    await _televisionRepository.UpdatePath(existingFile.Id, incomingFile.Path);
+                }
+            }
+        }
+
+        if (incomingVersion.DateUpdated > existingVersion.DateUpdated || !existingVersion.Streams.Any())
+        {
+            string localPath = _plexPathReplacementService.GetReplacementPlexPath(
+                pathReplacements,
+                incoming.MediaVersions.Head().MediaFiles.Head().Path,
+                false);
+                
+            _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
+            Either<BaseError, bool> refreshResult =
+                await _localStatisticsProvider.RefreshStatistics(ffprobePath, existing, localPath);
+                
+            await refreshResult.Match(
+                async _ =>
+                {
+                    foreach (MediaItem updated in await _searchRepository.GetItemToIndex(incoming.Id))
+                    {
+                        await _searchIndex.UpdateItems(
+                            _searchRepository,
+                            new List<MediaItem> { updated });
+                    }
+
+                    Either<BaseError, Tuple<EpisodeMetadata, MediaVersion>> maybeStatistics =
+                        await _plexServerApiClient.GetEpisodeMetadataAndStatistics(
+                            library,
+                            incoming.Key.Split("/").Last(),
+                            connection,
+                            token);
+
+                    await maybeStatistics.Match(
+                        async tuple =>
+                        {
+                            (EpisodeMetadata incomingMetadata, MediaVersion mediaVersion) = tuple;
+
+                            Option<EpisodeMetadata> maybeExisting = existing.EpisodeMetadata
+                                .Find(em => em.EpisodeNumber == incomingMetadata.EpisodeNumber);
+                            foreach (EpisodeMetadata existingMetadata in maybeExisting)
+                            {
+                                foreach (MetadataGuid guid in existingMetadata.Guids
+                                             .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                                             .ToList())
+                                {
+                                    existingMetadata.Guids.Remove(guid);
+                                    await _metadataRepository.RemoveGuid(guid);
+                                }
+
+                                foreach (MetadataGuid guid in incomingMetadata.Guids
+                                             .Filter(g => existingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                                             .ToList())
+                                {
+                                    existingMetadata.Guids.Add(guid);
+                                    await _metadataRepository.AddGuid(existingMetadata, guid);
+                                }
+                            }
+
+                            existingVersion.SampleAspectRatio = mediaVersion.SampleAspectRatio;
+                            existingVersion.VideoScanKind = mediaVersion.VideoScanKind;
+                            existingVersion.DateUpdated = mediaVersion.DateUpdated;
+
+                            await _metadataRepository.UpdatePlexStatistics(existingVersion.Id, mediaVersion);
+                        },
+                        _ => Task.CompletedTask);
                 },
                 error =>
                 {
                     _logger.LogWarning(
-                        "Error synchronizing plex library {Path}: {Error}",
-                        library.Name,
+                        "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
+                        "Statistics",
+                        localPath,
                         error.Value);
 
-                    return Left<BaseError, Unit>(error).AsTask();
+                    return Task.CompletedTask;
                 });
         }
 
-        private async Task<Either<BaseError, PlexEpisode>> UpdateMetadata(PlexEpisode existing, PlexEpisode incoming)
-        {
-            var toUpdate = existing.EpisodeMetadata
-                .Where(em => incoming.EpisodeMetadata.Any(em2 => em2.EpisodeNumber == em.EpisodeNumber))
-                .ToList();
-            var toRemove = existing.EpisodeMetadata.Except(toUpdate).ToList();
-            var toAdd = incoming.EpisodeMetadata
-                .Where(em => existing.EpisodeMetadata.All(em2 => em2.EpisodeNumber != em.EpisodeNumber))
-                .ToList();
-
-            foreach (EpisodeMetadata metadata in toRemove)
-            {
-                await _televisionRepository.RemoveMetadata(existing, metadata);
-            }
-
-            foreach (EpisodeMetadata metadata in toAdd)
-            {
-                metadata.EpisodeId = existing.Id;
-                metadata.Episode = existing;
-                existing.EpisodeMetadata.Add(metadata);
-
-                await _metadataRepository.Add(metadata);
-            }
-
-            // TODO: update existing metadata
-
-            return existing;
-        }
-
-        private async Task<Either<BaseError, PlexEpisode>> UpdateStatistics(
-            List<PlexPathReplacement> pathReplacements,
-            PlexEpisode existing,
-            PlexEpisode incoming,
-            PlexLibrary library,
-            PlexConnection connection,
-            PlexServerAuthToken token,
-            string ffprobePath)
-        {
-            MediaVersion existingVersion = existing.MediaVersions.Head();
-            MediaVersion incomingVersion = incoming.MediaVersions.Head();
-            
-            foreach (MediaFile incomingFile in incomingVersion.MediaFiles.HeadOrNone())
-            {
-                foreach (MediaFile existingFile in existingVersion.MediaFiles.HeadOrNone())
-                {
-                    if (incomingFile.Path != existingFile.Path)
-                    {
-                        _logger.LogDebug(
-                            "Plex episode has moved from {OldPath} to {NewPath}",
-                            existingFile.Path,
-                            incomingFile.Path);
-
-                        existingFile.Path = incomingFile.Path;
-
-                        await _televisionRepository.UpdatePath(existingFile.Id, incomingFile.Path);
-                    }
-                }
-            }
-
-            if (incomingVersion.DateUpdated > existingVersion.DateUpdated || !existingVersion.Streams.Any())
-            {
-                string localPath = _plexPathReplacementService.GetReplacementPlexPath(
-                    pathReplacements,
-                    incoming.MediaVersions.Head().MediaFiles.Head().Path,
-                    false);
-                
-                _logger.LogDebug("Refreshing {Attribute} for {Path}", "Statistics", localPath);
-                Either<BaseError, bool> refreshResult =
-                    await _localStatisticsProvider.RefreshStatistics(ffprobePath, existing, localPath);
-                
-                await refreshResult.Match(
-                    async _ =>
-                    {
-                        foreach (MediaItem updated in await _searchRepository.GetItemToIndex(incoming.Id))
-                        {
-                            await _searchIndex.UpdateItems(
-                                _searchRepository,
-                                new List<MediaItem> { updated });
-                        }
-
-                        Either<BaseError, Tuple<EpisodeMetadata, MediaVersion>> maybeStatistics =
-                            await _plexServerApiClient.GetEpisodeMetadataAndStatistics(
-                                library,
-                                incoming.Key.Split("/").Last(),
-                                connection,
-                                token);
-
-                        await maybeStatistics.Match(
-                            async tuple =>
-                            {
-                                (EpisodeMetadata incomingMetadata, MediaVersion mediaVersion) = tuple;
-
-                                Option<EpisodeMetadata> maybeExisting = existing.EpisodeMetadata
-                                    .Find(em => em.EpisodeNumber == incomingMetadata.EpisodeNumber);
-                                foreach (EpisodeMetadata existingMetadata in maybeExisting)
-                                {
-                                    foreach (MetadataGuid guid in existingMetadata.Guids
-                                        .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                                        .ToList())
-                                    {
-                                        existingMetadata.Guids.Remove(guid);
-                                        await _metadataRepository.RemoveGuid(guid);
-                                    }
-
-                                    foreach (MetadataGuid guid in incomingMetadata.Guids
-                                        .Filter(g => existingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                                        .ToList())
-                                    {
-                                        existingMetadata.Guids.Add(guid);
-                                        await _metadataRepository.AddGuid(existingMetadata, guid);
-                                    }
-                                }
-
-                                existingVersion.SampleAspectRatio = mediaVersion.SampleAspectRatio;
-                                existingVersion.VideoScanKind = mediaVersion.VideoScanKind;
-                                existingVersion.DateUpdated = mediaVersion.DateUpdated;
-
-                                await _metadataRepository.UpdatePlexStatistics(existingVersion.Id, mediaVersion);
-                            },
-                            _ => Task.CompletedTask);
-                    },
-                    error =>
-                    {
-                        _logger.LogWarning(
-                            "Unable to refresh {Attribute} for media item {Path}. Error: {Error}",
-                            "Statistics",
-                            localPath,
-                            error.Value);
-
-                        return Task.CompletedTask;
-                    });
-            }
-
-            return Right<BaseError, PlexEpisode>(existing);
-        }
-
-        private async Task<Either<BaseError, PlexEpisode>> UpdateArtwork(PlexEpisode existing, PlexEpisode incoming)
-        {
-            foreach (EpisodeMetadata incomingMetadata in incoming.EpisodeMetadata)
-            {
-                Option<EpisodeMetadata> maybeExistingMetadata = existing.EpisodeMetadata
-                    .Find(em => em.EpisodeNumber == incomingMetadata.EpisodeNumber);
-                if (maybeExistingMetadata.IsSome)
-                {
-                    EpisodeMetadata existingMetadata = maybeExistingMetadata.ValueUnsafe();
-                    if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
-                    {
-                        await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Thumbnail);
-                        await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
-                    }
-                }
-            }
-
-            return existing;
-        }
+        return Right<BaseError, PlexEpisode>(existing);
     }
-}
+
+    private async Task<Either<BaseError, PlexEpisode>> UpdateArtwork(PlexEpisode existing, PlexEpisode incoming)
+    {
+        foreach (EpisodeMetadata incomingMetadata in incoming.EpisodeMetadata)
+        {
+            Option<EpisodeMetadata> maybeExistingMetadata = existing.EpisodeMetadata
+                .Find(em => em.EpisodeNumber == incomingMetadata.EpisodeNumber);
+            if (maybeExistingMetadata.IsSome)
+            {
+                EpisodeMetadata existingMetadata = maybeExistingMetadata.ValueUnsafe();
+                if (incomingMetadata.DateUpdated > existingMetadata.DateUpdated)
+                {
+                    await UpdateArtworkIfNeeded(existingMetadata, incomingMetadata, ArtworkKind.Thumbnail);
+                    await _metadataRepository.MarkAsUpdated(existingMetadata, incomingMetadata.DateUpdated);
+                }
+            }
+        }
+
+        return existing;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Plex/PlexUserAuthToken.cs b/ErsatzTV.Core/Plex/PlexUserAuthToken.cs
index 4c305d2cb..f7afc478d 100644
--- a/ErsatzTV.Core/Plex/PlexUserAuthToken.cs
+++ b/ErsatzTV.Core/Plex/PlexUserAuthToken.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Core.Plex
-{
-    public record PlexUserAuthToken(string Email, string AuthToken);
-}
+namespace ErsatzTV.Core.Plex;
+
+public record PlexUserAuthToken(string Email, string AuthToken);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/ChronologicalMediaCollectionEnumerator.cs b/ErsatzTV.Core/Scheduling/ChronologicalMediaCollectionEnumerator.cs
index 75f56fdb3..74d62e742 100644
--- a/ErsatzTV.Core/Scheduling/ChronologicalMediaCollectionEnumerator.cs
+++ b/ErsatzTV.Core/Scheduling/ChronologicalMediaCollectionEnumerator.cs
@@ -1,44 +1,38 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public sealed class ChronologicalMediaCollectionEnumerator : IMediaCollectionEnumerator
 {
-    public sealed class ChronologicalMediaCollectionEnumerator : IMediaCollectionEnumerator
+    private readonly IList<MediaItem> _sortedMediaItems;
+
+    public ChronologicalMediaCollectionEnumerator(
+        IEnumerable<MediaItem> mediaItems,
+        CollectionEnumeratorState state)
     {
-        private readonly IList<MediaItem> _sortedMediaItems;
+        _sortedMediaItems = mediaItems.OrderBy(identity, new ChronologicalMediaComparer()).ToList();
 
-        public ChronologicalMediaCollectionEnumerator(
-            IEnumerable<MediaItem> mediaItems,
-            CollectionEnumeratorState state)
+        State = new CollectionEnumeratorState { Seed = state.Seed };
+
+        if (state.Index >= _sortedMediaItems.Count)
         {
-            _sortedMediaItems = mediaItems.OrderBy(identity, new ChronologicalMediaComparer()).ToList();
-
-            State = new CollectionEnumeratorState { Seed = state.Seed };
-
-            if (state.Index >= _sortedMediaItems.Count)
-            {
-                state.Index = 0;
-                state.Seed = 0;
-            }
-
-            while (State.Index < state.Index)
-            {
-                MoveNext();
-            }
+            state.Index = 0;
+            state.Seed = 0;
         }
 
-        public CollectionEnumeratorState State { get; }
-
-        public Option<MediaItem> Current => _sortedMediaItems.Any() ? _sortedMediaItems[State.Index] : None;
-
-        public void MoveNext() => State.Index = (State.Index + 1) % _sortedMediaItems.Count;
-
-        public Option<MediaItem> Peek(int offset) =>
-            _sortedMediaItems.Any() ? _sortedMediaItems[(State.Index + offset) % _sortedMediaItems.Count] : None;
+        while (State.Index < state.Index)
+        {
+            MoveNext();
+        }
     }
-}
+
+    public CollectionEnumeratorState State { get; }
+
+    public Option<MediaItem> Current => _sortedMediaItems.Any() ? _sortedMediaItems[State.Index] : None;
+
+    public void MoveNext() => State.Index = (State.Index + 1) % _sortedMediaItems.Count;
+
+    public Option<MediaItem> Peek(int offset) =>
+        _sortedMediaItems.Any() ? _sortedMediaItems[(State.Index + offset) % _sortedMediaItems.Count] : None;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/ChronologicalMediaComparer.cs b/ErsatzTV.Core/Scheduling/ChronologicalMediaComparer.cs
index 6a5c0682d..26f4d4ae0 100644
--- a/ErsatzTV.Core/Scheduling/ChronologicalMediaComparer.cs
+++ b/ErsatzTV.Core/Scheduling/ChronologicalMediaComparer.cs
@@ -1,141 +1,138 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+internal class ChronologicalMediaComparer : IComparer<MediaItem>
 {
-    internal class ChronologicalMediaComparer : IComparer<MediaItem>
+    public int Compare(MediaItem x, MediaItem y)
     {
-        public int Compare(MediaItem x, MediaItem y)
+        if (x == null || y == null)
         {
-            if (x == null || y == null)
-            {
-                return 0;
-            }
-
-            DateTime date1 = x switch
-            {
-                Episode e => e.EpisodeMetadata.HeadOrNone().Match(
-                    em => em.ReleaseDate ?? DateTime.MaxValue,
-                    () => DateTime.MaxValue),
-                Movie m => m.MovieMetadata.HeadOrNone().Match(
-                    mm => mm.ReleaseDate ?? DateTime.MaxValue,
-                    () => DateTime.MaxValue),
-                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
-                    mvm => mvm.ReleaseDate ?? DateTime.MaxValue,
-                    () => DateTime.MaxValue),
-                _ => DateTime.MaxValue
-            };
-
-            DateTime date2 = y switch
-            {
-                Episode e => e.EpisodeMetadata.HeadOrNone().Match(
-                    em => em.ReleaseDate ?? DateTime.MaxValue,
-                    () => DateTime.MaxValue),
-                Movie m => m.MovieMetadata.HeadOrNone().Match(
-                    mm => mm.ReleaseDate ?? DateTime.MaxValue,
-                    () => DateTime.MaxValue),
-                MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
-                    mvm => mvm.ReleaseDate ?? DateTime.MaxValue,
-                    () => DateTime.MaxValue),
-                _ => DateTime.MaxValue
-            };
-
-            if (date1 != date2)
-            {
-                return date1.CompareTo(date2);
-            }
-
-            string songDate1 = x switch
-            {
-                Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Date ?? string.Empty, () => string.Empty),
-                _ => string.Empty
-            };
-
-            string songDate2 = y switch
-            {
-                Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Date ?? string.Empty, () => string.Empty),
-                _ => string.Empty
-            };
-            
-            if (songDate1 != songDate2)
-            {
-                return string.Compare(songDate1, songDate2, StringComparison.Ordinal);
-            }
-
-            int season1 = x switch
-            {
-                Episode e => e.Season?.SeasonNumber ?? int.MaxValue,
-                _ => int.MaxValue
-            };
-
-            int season2 = y switch
-            {
-                Episode e => e.Season?.SeasonNumber ?? int.MaxValue,
-                _ => int.MaxValue
-            };
-
-            if (season1 != season2)
-            {
-                return season1.CompareTo(season2);
-            }
-
-            int episode1 = x switch
-            {
-                Episode e => e.EpisodeMetadata.HeadOrNone().Match(
-                    em => em.EpisodeNumber,
-                    () => int.MaxValue),
-                _ => int.MaxValue
-            };
-
-            int episode2 = y switch
-            {
-                Episode e => e.EpisodeMetadata.HeadOrNone().Match(
-                    em => em.EpisodeNumber,
-                    () => int.MaxValue),
-                _ => int.MaxValue
-            };
-
-            if (episode1 != episode2)
-            {
-                return episode1.CompareTo(episode2);
-            }
-
-            string album1 = x switch
-            {
-                Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Album ?? string.Empty, () => string.Empty),
-                _ => string.Empty
-            };
-
-            string album2 = y switch
-            {
-                Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Album ?? string.Empty, () => string.Empty),
-                _ => string.Empty
-            };
-
-            if (album1 != album2)
-            {
-                return string.Compare(album1, album2, StringComparison.Ordinal);
-            }
-
-            string track1 = x switch
-            {
-                Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Track ?? string.Empty, () => string.Empty),
-                _ => string.Empty
-            };
-
-            string track2 = y switch
-            {
-                Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Track ?? string.Empty, () => string.Empty),
-                _ => string.Empty
-            };
-
-            if (track1 != track2)
-            {
-                return string.Compare(track1, track2, StringComparison.Ordinal);
-            }
-
-            return x.Id.CompareTo(y.Id);
+            return 0;
         }
+
+        DateTime date1 = x switch
+        {
+            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
+                em => em.ReleaseDate ?? DateTime.MaxValue,
+                () => DateTime.MaxValue),
+            Movie m => m.MovieMetadata.HeadOrNone().Match(
+                mm => mm.ReleaseDate ?? DateTime.MaxValue,
+                () => DateTime.MaxValue),
+            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                mvm => mvm.ReleaseDate ?? DateTime.MaxValue,
+                () => DateTime.MaxValue),
+            _ => DateTime.MaxValue
+        };
+
+        DateTime date2 = y switch
+        {
+            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
+                em => em.ReleaseDate ?? DateTime.MaxValue,
+                () => DateTime.MaxValue),
+            Movie m => m.MovieMetadata.HeadOrNone().Match(
+                mm => mm.ReleaseDate ?? DateTime.MaxValue,
+                () => DateTime.MaxValue),
+            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                mvm => mvm.ReleaseDate ?? DateTime.MaxValue,
+                () => DateTime.MaxValue),
+            _ => DateTime.MaxValue
+        };
+
+        if (date1 != date2)
+        {
+            return date1.CompareTo(date2);
+        }
+
+        string songDate1 = x switch
+        {
+            Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Date ?? string.Empty, () => string.Empty),
+            _ => string.Empty
+        };
+
+        string songDate2 = y switch
+        {
+            Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Date ?? string.Empty, () => string.Empty),
+            _ => string.Empty
+        };
+            
+        if (songDate1 != songDate2)
+        {
+            return string.Compare(songDate1, songDate2, StringComparison.Ordinal);
+        }
+
+        int season1 = x switch
+        {
+            Episode e => e.Season?.SeasonNumber ?? int.MaxValue,
+            _ => int.MaxValue
+        };
+
+        int season2 = y switch
+        {
+            Episode e => e.Season?.SeasonNumber ?? int.MaxValue,
+            _ => int.MaxValue
+        };
+
+        if (season1 != season2)
+        {
+            return season1.CompareTo(season2);
+        }
+
+        int episode1 = x switch
+        {
+            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
+                em => em.EpisodeNumber,
+                () => int.MaxValue),
+            _ => int.MaxValue
+        };
+
+        int episode2 = y switch
+        {
+            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
+                em => em.EpisodeNumber,
+                () => int.MaxValue),
+            _ => int.MaxValue
+        };
+
+        if (episode1 != episode2)
+        {
+            return episode1.CompareTo(episode2);
+        }
+
+        string album1 = x switch
+        {
+            Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Album ?? string.Empty, () => string.Empty),
+            _ => string.Empty
+        };
+
+        string album2 = y switch
+        {
+            Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Album ?? string.Empty, () => string.Empty),
+            _ => string.Empty
+        };
+
+        if (album1 != album2)
+        {
+            return string.Compare(album1, album2, StringComparison.Ordinal);
+        }
+
+        string track1 = x switch
+        {
+            Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Track ?? string.Empty, () => string.Empty),
+            _ => string.Empty
+        };
+
+        string track2 = y switch
+        {
+            Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Track ?? string.Empty, () => string.Empty),
+            _ => string.Empty
+        };
+
+        if (track1 != track2)
+        {
+            return string.Compare(track1, track2, StringComparison.Ordinal);
+        }
+
+        return x.Id.CompareTo(y.Id);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/CloneableRandom.cs b/ErsatzTV.Core/Scheduling/CloneableRandom.cs
index 29ce97a90..fbe8f06a0 100644
--- a/ErsatzTV.Core/Scheduling/CloneableRandom.cs
+++ b/ErsatzTV.Core/Scheduling/CloneableRandom.cs
@@ -1,41 +1,38 @@
-using System;
+namespace ErsatzTV.Core.Scheduling;
 
-namespace ErsatzTV.Core.Scheduling
+public class CloneableRandom
 {
-    public class CloneableRandom
-    {
-        private readonly int _seed;
-        private readonly Random _random;
-        private int _count;
+    private readonly int _seed;
+    private readonly Random _random;
+    private int _count;
         
-        public CloneableRandom(int seed)
-        {
-            _seed = seed;
-            _random = new Random(_seed);
-        }
-
-        public CloneableRandom Clone()
-        {
-            var clone = new CloneableRandom(_seed);
-            
-            for (var i = 0; i < _count; i++)
-            {
-                clone.Next();
-            }
-
-            return clone;
-        }
-
-        public int Next()
-        {
-            _count++;
-            return _random.Next();
-        }
-
-        public int Next(int maxValue)
-        {
-            _count++;
-            return _random.Next(maxValue);
-        }
+    public CloneableRandom(int seed)
+    {
+        _seed = seed;
+        _random = new Random(_seed);
     }
-}
+
+    public CloneableRandom Clone()
+    {
+        var clone = new CloneableRandom(_seed);
+            
+        for (var i = 0; i < _count; i++)
+        {
+            clone.Next();
+        }
+
+        return clone;
+    }
+
+    public int Next()
+    {
+        _count++;
+        return _random.Next();
+    }
+
+    public int Next(int maxValue)
+    {
+        _count++;
+        return _random.Next(maxValue);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/CollectionKey.cs b/ErsatzTV.Core/Scheduling/CollectionKey.cs
index afa86c965..dbd6122d4 100644
--- a/ErsatzTV.Core/Scheduling/CollectionKey.cs
+++ b/ErsatzTV.Core/Scheduling/CollectionKey.cs
@@ -1,88 +1,85 @@
-using System;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class CollectionKey : Record<CollectionKey>
 {
-    public class CollectionKey : Record<CollectionKey>
-    {
-        public static CollectionKey ForScheduleItem(ProgramScheduleItem item) =>
-            item.CollectionType switch
+    public static CollectionKey ForScheduleItem(ProgramScheduleItem item) =>
+        item.CollectionType switch
+        {
+            ProgramScheduleItemCollectionType.Collection => new CollectionKey
             {
-                ProgramScheduleItemCollectionType.Collection => new CollectionKey
-                {
-                    CollectionType = item.CollectionType,
-                    CollectionId = item.CollectionId
-                },
-                ProgramScheduleItemCollectionType.TelevisionShow => new CollectionKey
-                {
-                    CollectionType = item.CollectionType,
-                    MediaItemId = item.MediaItemId
-                },
-                ProgramScheduleItemCollectionType.TelevisionSeason => new CollectionKey
-                {
-                    CollectionType = item.CollectionType,
-                    MediaItemId = item.MediaItemId
-                },
-                ProgramScheduleItemCollectionType.Artist => new CollectionKey
-                {
-                    CollectionType = item.CollectionType,
-                    MediaItemId = item.MediaItemId
-                },
-                ProgramScheduleItemCollectionType.MultiCollection => new CollectionKey
-                {
-                    CollectionType = item.CollectionType,
-                    MultiCollectionId = item.MultiCollectionId
-                },
-                ProgramScheduleItemCollectionType.SmartCollection => new CollectionKey
-                {
-                    CollectionType = item.CollectionType,
-                    SmartCollectionId = item.SmartCollectionId
-                },
-                _ => throw new ArgumentOutOfRangeException(nameof(item))
-            };
-        
-        public static CollectionKey ForFillerPreset(FillerPreset filler) =>
-            filler.CollectionType switch
+                CollectionType = item.CollectionType,
+                CollectionId = item.CollectionId
+            },
+            ProgramScheduleItemCollectionType.TelevisionShow => new CollectionKey
             {
-                ProgramScheduleItemCollectionType.Collection => new CollectionKey
-                {
-                    CollectionType = filler.CollectionType,
-                    CollectionId = filler.CollectionId
-                },
-                ProgramScheduleItemCollectionType.TelevisionShow => new CollectionKey
-                {
-                    CollectionType = filler.CollectionType,
-                    MediaItemId = filler.MediaItemId
-                },
-                ProgramScheduleItemCollectionType.TelevisionSeason => new CollectionKey
-                {
-                    CollectionType = filler.CollectionType,
-                    MediaItemId = filler.MediaItemId
-                },
-                ProgramScheduleItemCollectionType.Artist => new CollectionKey
-                {
-                    CollectionType = filler.CollectionType,
-                    MediaItemId = filler.MediaItemId
-                },
-                ProgramScheduleItemCollectionType.MultiCollection => new CollectionKey
-                {
-                    CollectionType = filler.CollectionType,
-                    MultiCollectionId = filler.MultiCollectionId
-                },
-                ProgramScheduleItemCollectionType.SmartCollection => new CollectionKey
-                {
-                    CollectionType = filler.CollectionType,
-                    SmartCollectionId = filler.SmartCollectionId
-                },
-                _ => throw new ArgumentOutOfRangeException(nameof(filler))
-            };
+                CollectionType = item.CollectionType,
+                MediaItemId = item.MediaItemId
+            },
+            ProgramScheduleItemCollectionType.TelevisionSeason => new CollectionKey
+            {
+                CollectionType = item.CollectionType,
+                MediaItemId = item.MediaItemId
+            },
+            ProgramScheduleItemCollectionType.Artist => new CollectionKey
+            {
+                CollectionType = item.CollectionType,
+                MediaItemId = item.MediaItemId
+            },
+            ProgramScheduleItemCollectionType.MultiCollection => new CollectionKey
+            {
+                CollectionType = item.CollectionType,
+                MultiCollectionId = item.MultiCollectionId
+            },
+            ProgramScheduleItemCollectionType.SmartCollection => new CollectionKey
+            {
+                CollectionType = item.CollectionType,
+                SmartCollectionId = item.SmartCollectionId
+            },
+            _ => throw new ArgumentOutOfRangeException(nameof(item))
+        };
         
-        public ProgramScheduleItemCollectionType CollectionType { get; set; }
-        public int? CollectionId { get; set; }
-        public int? MultiCollectionId { get; set; }
-        public int? SmartCollectionId { get; set; }
-        public int? MediaItemId { get; set; }
-    }
-}
+    public static CollectionKey ForFillerPreset(FillerPreset filler) =>
+        filler.CollectionType switch
+        {
+            ProgramScheduleItemCollectionType.Collection => new CollectionKey
+            {
+                CollectionType = filler.CollectionType,
+                CollectionId = filler.CollectionId
+            },
+            ProgramScheduleItemCollectionType.TelevisionShow => new CollectionKey
+            {
+                CollectionType = filler.CollectionType,
+                MediaItemId = filler.MediaItemId
+            },
+            ProgramScheduleItemCollectionType.TelevisionSeason => new CollectionKey
+            {
+                CollectionType = filler.CollectionType,
+                MediaItemId = filler.MediaItemId
+            },
+            ProgramScheduleItemCollectionType.Artist => new CollectionKey
+            {
+                CollectionType = filler.CollectionType,
+                MediaItemId = filler.MediaItemId
+            },
+            ProgramScheduleItemCollectionType.MultiCollection => new CollectionKey
+            {
+                CollectionType = filler.CollectionType,
+                MultiCollectionId = filler.MultiCollectionId
+            },
+            ProgramScheduleItemCollectionType.SmartCollection => new CollectionKey
+            {
+                CollectionType = filler.CollectionType,
+                SmartCollectionId = filler.SmartCollectionId
+            },
+            _ => throw new ArgumentOutOfRangeException(nameof(filler))
+        };
+        
+    public ProgramScheduleItemCollectionType CollectionType { get; set; }
+    public int? CollectionId { get; set; }
+    public int? MultiCollectionId { get; set; }
+    public int? SmartCollectionId { get; set; }
+    public int? MediaItemId { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/CollectionWithItems.cs b/ErsatzTV.Core/Scheduling/CollectionWithItems.cs
index 855132382..f5f133392 100644
--- a/ErsatzTV.Core/Scheduling/CollectionWithItems.cs
+++ b/ErsatzTV.Core/Scheduling/CollectionWithItems.cs
@@ -1,12 +1,10 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Scheduling
-{
-    public record CollectionWithItems(
-        int CollectionId,
-        List<MediaItem> MediaItems,
-        bool ScheduleAsGroup,
-        PlaybackOrder PlaybackOrder,
-        bool UseCustomOrder);
-}
+namespace ErsatzTV.Core.Scheduling;
+
+public record CollectionWithItems(
+    int CollectionId,
+    List<MediaItem> MediaItems,
+    bool ScheduleAsGroup,
+    PlaybackOrder PlaybackOrder,
+    bool UseCustomOrder);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/CustomOrderCollectionEnumerator.cs b/ErsatzTV.Core/Scheduling/CustomOrderCollectionEnumerator.cs
index ee15894fa..5aca9845a 100644
--- a/ErsatzTV.Core/Scheduling/CustomOrderCollectionEnumerator.cs
+++ b/ErsatzTV.Core/Scheduling/CustomOrderCollectionEnumerator.cs
@@ -1,45 +1,39 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class CustomOrderCollectionEnumerator : IMediaCollectionEnumerator
 {
-    public class CustomOrderCollectionEnumerator : IMediaCollectionEnumerator
+    private readonly Collection _collection;
+    private readonly IList<MediaItem> _sortedMediaItems;
+
+    public CustomOrderCollectionEnumerator(
+        Collection collection,
+        IList<MediaItem> mediaItems,
+        CollectionEnumeratorState state)
     {
-        private readonly Collection _collection;
-        private readonly IList<MediaItem> _sortedMediaItems;
+        _collection = collection;
 
-        public CustomOrderCollectionEnumerator(
-            Collection collection,
-            IList<MediaItem> mediaItems,
-            CollectionEnumeratorState state)
+        // TODO: this will break if we allow shows and seasons
+        _sortedMediaItems = collection.CollectionItems
+            .OrderBy(ci => ci.CustomIndex)
+            .Map(ci => mediaItems.First(mi => mi.Id == ci.MediaItemId))
+            .ToList();
+
+        State = new CollectionEnumeratorState { Seed = state.Seed };
+        while (State.Index < state.Index)
         {
-            _collection = collection;
-
-            // TODO: this will break if we allow shows and seasons
-            _sortedMediaItems = collection.CollectionItems
-                .OrderBy(ci => ci.CustomIndex)
-                .Map(ci => mediaItems.First(mi => mi.Id == ci.MediaItemId))
-                .ToList();
-
-            State = new CollectionEnumeratorState { Seed = state.Seed };
-            while (State.Index < state.Index)
-            {
-                MoveNext();
-            }
+            MoveNext();
         }
-
-        public CollectionEnumeratorState State { get; }
-
-        public Option<MediaItem> Current => _sortedMediaItems.Any() ? _sortedMediaItems[State.Index] : None;
-
-        public void MoveNext() => State.Index = (State.Index + 1) % _sortedMediaItems.Count;
-
-        public Option<MediaItem> Peek(int offset) =>
-            throw new NotSupportedException();
     }
-}
+
+    public CollectionEnumeratorState State { get; }
+
+    public Option<MediaItem> Current => _sortedMediaItems.Any() ? _sortedMediaItems[State.Index] : None;
+
+    public void MoveNext() => State.Index = (State.Index + 1) % _sortedMediaItems.Count;
+
+    public Option<MediaItem> Peek(int offset) =>
+        throw new NotSupportedException();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/GroupedMediaItem.cs b/ErsatzTV.Core/Scheduling/GroupedMediaItem.cs
index 79c19da36..2b469e033 100644
--- a/ErsatzTV.Core/Scheduling/GroupedMediaItem.cs
+++ b/ErsatzTV.Core/Scheduling/GroupedMediaItem.cs
@@ -1,40 +1,37 @@
-using System.Collections.Generic;
-using System.Diagnostics;
+using System.Diagnostics;
 using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+[DebuggerDisplay("{" + nameof(First) + "}")]
+public class GroupedMediaItem
 {
-    [DebuggerDisplay("{" + nameof(First) + "}")]
-    public class GroupedMediaItem
+    public GroupedMediaItem()
     {
-        public GroupedMediaItem()
-        {
-        }
-
-        public GroupedMediaItem(MediaItem first, List<MediaItem> additional)
-        {
-            First = first;
-            Additional = additional ?? new List<MediaItem>();
-        }
-
-        public MediaItem First { get; set; }
-        public List<MediaItem> Additional { get; set; }
-        
-        public static IList<MediaItem> FlattenGroups(GroupedMediaItem[] copy, int mediaItemCount)
-        {
-            var result = new MediaItem[mediaItemCount];
-            var i = 0;
-            foreach (GroupedMediaItem group in copy)
-            {
-                result[i++] = group.First;
-                foreach (MediaItem additional in Optional(group.Additional).Flatten())
-                {
-                    result[i++] = additional;
-                }
-            }
-
-            return result;
-        }
     }
-}
+
+    public GroupedMediaItem(MediaItem first, List<MediaItem> additional)
+    {
+        First = first;
+        Additional = additional ?? new List<MediaItem>();
+    }
+
+    public MediaItem First { get; set; }
+    public List<MediaItem> Additional { get; set; }
+        
+    public static IList<MediaItem> FlattenGroups(GroupedMediaItem[] copy, int mediaItemCount)
+    {
+        var result = new MediaItem[mediaItemCount];
+        var i = 0;
+        foreach (GroupedMediaItem group in copy)
+        {
+            result[i++] = group.First;
+            foreach (MediaItem additional in Optional(group.Additional).Flatten())
+            {
+                result[i++] = additional;
+            }
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/MediaItemsForCollection.cs b/ErsatzTV.Core/Scheduling/MediaItemsForCollection.cs
index 79099779c..36bff55d8 100644
--- a/ErsatzTV.Core/Scheduling/MediaItemsForCollection.cs
+++ b/ErsatzTV.Core/Scheduling/MediaItemsForCollection.cs
@@ -1,51 +1,47 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 
-namespace ErsatzTV.Core.Scheduling
-{
-    public static class MediaItemsForCollection
-    {
-        public static async Task<List<MediaItem>> Collect(
-            IMediaCollectionRepository mediaCollectionRepository,
-            ITelevisionRepository televisionRepository,
-            IArtistRepository artistRepository,
-            CollectionKey collectionKey)
-        {
-            switch (collectionKey.CollectionType)
-            {
-                case ProgramScheduleItemCollectionType.Collection:
-                    List<MediaItem> collectionItems =
-                        await mediaCollectionRepository.GetItems(collectionKey.CollectionId ?? 0);
-                    return collectionItems;
-                case ProgramScheduleItemCollectionType.TelevisionShow:
-                    List<Episode> showItems =
-                        await televisionRepository.GetShowItems(collectionKey.MediaItemId ?? 0);
-                    return showItems.Cast<MediaItem>().ToList();
-                case ProgramScheduleItemCollectionType.TelevisionSeason:
-                    List<Episode> seasonItems =
-                        await televisionRepository.GetSeasonItems(collectionKey.MediaItemId ?? 0);
-                    return seasonItems.Cast<MediaItem>().ToList();
-                case ProgramScheduleItemCollectionType.Artist:
-                    List<MusicVideo> artistItems =
-                        await artistRepository.GetArtistItems(collectionKey.MediaItemId ?? 0);
-                    return artistItems.Cast<MediaItem>().ToList();
-                case ProgramScheduleItemCollectionType.MultiCollection:
-                    List<MediaItem> multiCollectionItems =
-                        await mediaCollectionRepository.GetMultiCollectionItems(
-                            collectionKey.MultiCollectionId ?? 0);
-                    return multiCollectionItems;
-                case ProgramScheduleItemCollectionType.SmartCollection:
-                    List<MediaItem> smartCollectionItems =
-                        await mediaCollectionRepository.GetSmartCollectionItems(
-                            collectionKey.SmartCollectionId ?? 0);
-                    return smartCollectionItems;
-                default:
-                    return new List<MediaItem>();
-            }
-        }
+namespace ErsatzTV.Core.Scheduling;
 
+public static class MediaItemsForCollection
+{
+    public static async Task<List<MediaItem>> Collect(
+        IMediaCollectionRepository mediaCollectionRepository,
+        ITelevisionRepository televisionRepository,
+        IArtistRepository artistRepository,
+        CollectionKey collectionKey)
+    {
+        switch (collectionKey.CollectionType)
+        {
+            case ProgramScheduleItemCollectionType.Collection:
+                List<MediaItem> collectionItems =
+                    await mediaCollectionRepository.GetItems(collectionKey.CollectionId ?? 0);
+                return collectionItems;
+            case ProgramScheduleItemCollectionType.TelevisionShow:
+                List<Episode> showItems =
+                    await televisionRepository.GetShowItems(collectionKey.MediaItemId ?? 0);
+                return showItems.Cast<MediaItem>().ToList();
+            case ProgramScheduleItemCollectionType.TelevisionSeason:
+                List<Episode> seasonItems =
+                    await televisionRepository.GetSeasonItems(collectionKey.MediaItemId ?? 0);
+                return seasonItems.Cast<MediaItem>().ToList();
+            case ProgramScheduleItemCollectionType.Artist:
+                List<MusicVideo> artistItems =
+                    await artistRepository.GetArtistItems(collectionKey.MediaItemId ?? 0);
+                return artistItems.Cast<MediaItem>().ToList();
+            case ProgramScheduleItemCollectionType.MultiCollection:
+                List<MediaItem> multiCollectionItems =
+                    await mediaCollectionRepository.GetMultiCollectionItems(
+                        collectionKey.MultiCollectionId ?? 0);
+                return multiCollectionItems;
+            case ProgramScheduleItemCollectionType.SmartCollection:
+                List<MediaItem> smartCollectionItems =
+                    await mediaCollectionRepository.GetSmartCollectionItems(
+                        collectionKey.SmartCollectionId ?? 0);
+                return smartCollectionItems;
+            default:
+                return new List<MediaItem>();
+        }
     }
-}
+
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/MultiCollectionGroup.cs b/ErsatzTV.Core/Scheduling/MultiCollectionGroup.cs
index 1ba372a8b..1fa38033f 100644
--- a/ErsatzTV.Core/Scheduling/MultiCollectionGroup.cs
+++ b/ErsatzTV.Core/Scheduling/MultiCollectionGroup.cs
@@ -1,41 +1,37 @@
-using System;
-using System.Linq;
-using ErsatzTV.Core.Domain;
-using static LanguageExt.Prelude;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class MultiCollectionGroup : GroupedMediaItem
 {
-    public class MultiCollectionGroup : GroupedMediaItem
+    public MultiCollectionGroup(CollectionWithItems collectionWithItems)
     {
-        public MultiCollectionGroup(CollectionWithItems collectionWithItems)
+        if (collectionWithItems.UseCustomOrder)
         {
-            if (collectionWithItems.UseCustomOrder)
+            if (collectionWithItems.MediaItems.Count > 0)
             {
-                if (collectionWithItems.MediaItems.Count > 0)
-                {
-                    First = collectionWithItems.MediaItems.Head();
-                    Additional = collectionWithItems.MediaItems.Tail().ToList();
-                }
-                else
-                {
-                    throw new InvalidOperationException("Collection has no items");
-                }
+                First = collectionWithItems.MediaItems.Head();
+                Additional = collectionWithItems.MediaItems.Tail().ToList();
             }
             else
             {
-                switch (collectionWithItems.PlaybackOrder)
-                {
-                    case PlaybackOrder.Chronological:
-                        var sortedItems = collectionWithItems.MediaItems.OrderBy(identity, new ChronologicalMediaComparer())
-                            .ToList();
-                        First = sortedItems.Head();
-                        Additional = sortedItems.Tail().ToList();
-                        break;
-                    default:
-                        throw new NotSupportedException(
-                            $"Unsupported MultiCollection PlaybackOrder: {collectionWithItems.PlaybackOrder}");
-                }
+                throw new InvalidOperationException("Collection has no items");
+            }
+        }
+        else
+        {
+            switch (collectionWithItems.PlaybackOrder)
+            {
+                case PlaybackOrder.Chronological:
+                    var sortedItems = collectionWithItems.MediaItems.OrderBy(identity, new ChronologicalMediaComparer())
+                        .ToList();
+                    First = sortedItems.Head();
+                    Additional = sortedItems.Tail().ToList();
+                    break;
+                default:
+                    throw new NotSupportedException(
+                        $"Unsupported MultiCollection PlaybackOrder: {collectionWithItems.PlaybackOrder}");
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/MultiCollectionGrouper.cs b/ErsatzTV.Core/Scheduling/MultiCollectionGrouper.cs
index ecbad2399..aa47c5c8c 100644
--- a/ErsatzTV.Core/Scheduling/MultiCollectionGrouper.cs
+++ b/ErsatzTV.Core/Scheduling/MultiCollectionGrouper.cs
@@ -1,27 +1,23 @@
-using System.Collections.Generic;
-using System.Linq;
+namespace ErsatzTV.Core.Scheduling;
 
-namespace ErsatzTV.Core.Scheduling
+public class MultiCollectionGrouper
 {
-    public class MultiCollectionGrouper
+    public static List<GroupedMediaItem> GroupMediaItems(IList<CollectionWithItems> collections)
     {
-        public static List<GroupedMediaItem> GroupMediaItems(IList<CollectionWithItems> collections)
+        var result = new List<GroupedMediaItem>();
+
+        foreach (CollectionWithItems collection in collections.Where(collection => collection.MediaItems.Any()))
         {
-            var result = new List<GroupedMediaItem>();
-
-            foreach (CollectionWithItems collection in collections.Where(collection => collection.MediaItems.Any()))
+            if (collection.ScheduleAsGroup)
             {
-                if (collection.ScheduleAsGroup)
-                {
-                    result.Add(new MultiCollectionGroup(collection));
-                }
-                else
-                {
-                    result.AddRange(collection.MediaItems.Map(i => new GroupedMediaItem { First = i }));
-                }
+                result.Add(new MultiCollectionGroup(collection));
+            }
+            else
+            {
+                result.AddRange(collection.MediaItems.Map(i => new GroupedMediaItem { First = i }));
             }
-
-            return result;
         }
+
+        return result;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/MultiPartEpisodeGrouper.cs b/ErsatzTV.Core/Scheduling/MultiPartEpisodeGrouper.cs
index e5fa29841..658c9c04b 100644
--- a/ErsatzTV.Core/Scheduling/MultiPartEpisodeGrouper.cs
+++ b/ErsatzTV.Core/Scheduling/MultiPartEpisodeGrouper.cs
@@ -1,97 +1,87 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public static class MultiPartEpisodeGrouper
 {
-    public static class MultiPartEpisodeGrouper
+    public static List<GroupedMediaItem> GroupMediaItems(IList<MediaItem> mediaItems, bool treatCollectionsAsShows)
     {
-        public static List<GroupedMediaItem> GroupMediaItems(IList<MediaItem> mediaItems, bool treatCollectionsAsShows)
+        var episodes = mediaItems.OfType<Episode>().ToList();
+        // var showIds = episodes.Map(e => e.Season.ShowId).Distinct().ToList();
+
+        var groups = new List<GroupedMediaItem>();
+        GroupedMediaItem group = null;
+
+        var showIds = new List<Option<int>>();
+        if (treatCollectionsAsShows)
         {
-            var episodes = mediaItems.OfType<Episode>().ToList();
-            // var showIds = episodes.Map(e => e.Season.ShowId).Distinct().ToList();
+            showIds.Add(Option<int>.None);
+        }
+        else
+        {
+            showIds.AddRange(episodes.Map(e => Some(e.Season.ShowId)).Distinct());
+        }
 
-            var groups = new List<GroupedMediaItem>();
-            GroupedMediaItem group = null;
+        foreach (Option<int> showId in showIds)
+        {
+            var lastNumber = 0;
 
-            var showIds = new List<Option<int>>();
-            if (treatCollectionsAsShows)
+            void AddUngrouped(MediaItem item)
             {
-                showIds.Add(Option<int>.None);
-            }
-            else
-            {
-                showIds.AddRange(episodes.Map(e => Some(e.Season.ShowId)).Distinct());
-            }
-
-            foreach (Option<int> showId in showIds)
-            {
-                var lastNumber = 0;
-
-                void AddUngrouped(MediaItem item)
+                if (group != null && lastNumber != 0)
                 {
-                    if (group != null && lastNumber != 0)
+                    groups.Add(group);
+                    group = null;
+                    lastNumber = 0;
+                }
+
+                groups.Add(new GroupedMediaItem(item, null));
+            }
+
+            IEnumerable<Episode> sortedEpisodes = showId.Match(
+                id => episodes.Filter(e => e.Season.ShowId == id),
+                () => episodes).OrderBy(identity, new ChronologicalMediaComparer());
+
+            foreach (Episode episode in sortedEpisodes)
+            {
+                Option<int> maybeNumber = FindPartNumber(episode);
+                if (maybeNumber.IsSome)
+                {
+                    int number = maybeNumber.ValueUnsafe();
+                    if (number <= lastNumber && group != null)
                     {
                         groups.Add(group);
                         group = null;
                         lastNumber = 0;
                     }
 
-                    groups.Add(new GroupedMediaItem(item, null));
-                }
-
-                IEnumerable<Episode> sortedEpisodes = showId.Match(
-                    id => episodes.Filter(e => e.Season.ShowId == id),
-                    () => episodes).OrderBy(identity, new ChronologicalMediaComparer());
-
-                foreach (Episode episode in sortedEpisodes)
-                {
-                    Option<int> maybeNumber = FindPartNumber(episode);
-                    if (maybeNumber.IsSome)
+                    if (number > lastNumber)
                     {
-                        int number = maybeNumber.ValueUnsafe();
-                        if (number <= lastNumber && group != null)
+                        if (lastNumber == 0)
                         {
-                            groups.Add(group);
-                            group = null;
-                            lastNumber = 0;
+                            // start a new group
+                            group = new GroupedMediaItem(episode, null);
+                            lastNumber = number;
                         }
-
-                        if (number > lastNumber)
+                        else if (number == lastNumber + 1)
                         {
-                            if (lastNumber == 0)
+                            if (group != null)
                             {
-                                // start a new group
-                                group = new GroupedMediaItem(episode, null);
-                                lastNumber = number;
-                            }
-                            else if (number == lastNumber + 1)
-                            {
-                                if (group != null)
-                                {
-                                    // add to current group
-                                    List<MediaItem> additional = group.Additional ?? new List<MediaItem>();
-                                    additional.Add(episode);
-                                    group = new GroupedMediaItem(group.First, additional);
-                                }
-                                else
-                                {
-                                    // this should never happen
-                                    throw new InvalidOperationException(
-                                        $"Bad shuffle state; unexpected number {number} after {lastNumber} with no existing group");
-                                }
-
-                                lastNumber = number;
+                                // add to current group
+                                List<MediaItem> additional = group.Additional ?? new List<MediaItem>();
+                                additional.Add(episode);
+                                group = new GroupedMediaItem(group.First, additional);
                             }
                             else
                             {
-                                AddUngrouped(episode);
+                                // this should never happen
+                                throw new InvalidOperationException(
+                                    $"Bad shuffle state; unexpected number {number} after {lastNumber} with no existing group");
                             }
+
+                            lastNumber = number;
                         }
                         else
                         {
@@ -103,136 +93,140 @@ namespace ErsatzTV.Core.Scheduling
                         AddUngrouped(episode);
                     }
                 }
-
-                if (group != null && lastNumber != 0)
+                else
                 {
-                    groups.Add(group);
-                    group = null;
+                    AddUngrouped(episode);
                 }
             }
 
-            foreach (MediaItem notEpisode in mediaItems.Filter(i => i is not Episode))
+            if (group != null && lastNumber != 0)
             {
-                groups.Add(new GroupedMediaItem(notEpisode, null));
-            }
-
-            return groups;
-        }
-
-        private static Option<int> FindPartNumber(Episode e)
-        {
-            foreach (EpisodeMetadata metadata in e.EpisodeMetadata.HeadOrNone())
-            {
-                const string PATTERN = @"^.*\((\d+)\)( - .*)?$";
-                Match match = Regex.Match(metadata.Title ?? string.Empty, PATTERN);
-                if (match.Success && int.TryParse(match.Groups[1].Value, out int value1))
-                {
-                    return value1;
-                }
-
-                const string PATTERN_2 = @"^.*\(?Part (\d+)\)?$";
-                Match match2 = Regex.Match(metadata.Title ?? string.Empty, PATTERN_2);
-                if (match2.Success && int.TryParse(match2.Groups[1].Value, out int value2))
-                {
-                    return value2;
-                }
-
-                const string PATTERN_3 = @"^.*\(([MDCLXVI]+)\)( - .*)?$";
-                Match match3 = Regex.Match(metadata.Title ?? string.Empty, PATTERN_3);
-                if (match3.Success && TryParseRoman(match3.Groups[1].Value, out int value3))
-                {
-                    return value3;
-                }
-
-                const string PATTERN_4 = @"^.*Part (\w+)$";
-                Match match4 = Regex.Match(metadata.Title ?? string.Empty, PATTERN_4);
-                if (match4.Success && TryParseEnglish(match4.Groups[1].Value, out int value4))
-                {
-                    return value4;
-                }
-            }
-
-            return None;
-        }
-
-        private static bool TryParseRoman(string input, out int output)
-        {
-            switch (input?.ToLowerInvariant())
-            {
-                case "i":
-                    output = 1;
-                    return true;
-                case "ii":
-                    output = 2;
-                    return true;
-                case "iii":
-                    output = 3;
-                    return true;
-                case "iv":
-                    output = 4;
-                    return true;
-                case "v":
-                    output = 5;
-                    return true;
-                case "vi":
-                    output = 6;
-                    return true;
-                case "vii":
-                    output = 7;
-                    return true;
-                case "viii" or "iix":
-                    output = 8;
-                    return true;
-                case "ix":
-                    output = 9;
-                    return true;
-                case "x":
-                    output = 10;
-                    return true;
-                default:
-                    output = 0;
-                    return false;
+                groups.Add(group);
+                group = null;
             }
         }
 
-        private static bool TryParseEnglish(string input, out int output)
+        foreach (MediaItem notEpisode in mediaItems.Filter(i => i is not Episode))
         {
-            switch (input?.ToLowerInvariant())
+            groups.Add(new GroupedMediaItem(notEpisode, null));
+        }
+
+        return groups;
+    }
+
+    private static Option<int> FindPartNumber(Episode e)
+    {
+        foreach (EpisodeMetadata metadata in e.EpisodeMetadata.HeadOrNone())
+        {
+            const string PATTERN = @"^.*\((\d+)\)( - .*)?$";
+            Match match = Regex.Match(metadata.Title ?? string.Empty, PATTERN);
+            if (match.Success && int.TryParse(match.Groups[1].Value, out int value1))
             {
-                case "one":
-                    output = 1;
-                    return true;
-                case "two":
-                    output = 2;
-                    return true;
-                case "three":
-                    output = 3;
-                    return true;
-                case "four":
-                    output = 4;
-                    return true;
-                case "five":
-                    output = 5;
-                    return true;
-                case "six":
-                    output = 6;
-                    return true;
-                case "seven":
-                    output = 7;
-                    return true;
-                case "eight":
-                    output = 8;
-                    return true;
-                case "nine":
-                    output = 9;
-                    return true;
-                case "ten":
-                    output = 10;
-                    return true;
-                default:
-                    output = 0;
-                    return false;
+                return value1;
             }
+
+            const string PATTERN_2 = @"^.*\(?Part (\d+)\)?$";
+            Match match2 = Regex.Match(metadata.Title ?? string.Empty, PATTERN_2);
+            if (match2.Success && int.TryParse(match2.Groups[1].Value, out int value2))
+            {
+                return value2;
+            }
+
+            const string PATTERN_3 = @"^.*\(([MDCLXVI]+)\)( - .*)?$";
+            Match match3 = Regex.Match(metadata.Title ?? string.Empty, PATTERN_3);
+            if (match3.Success && TryParseRoman(match3.Groups[1].Value, out int value3))
+            {
+                return value3;
+            }
+
+            const string PATTERN_4 = @"^.*Part (\w+)$";
+            Match match4 = Regex.Match(metadata.Title ?? string.Empty, PATTERN_4);
+            if (match4.Success && TryParseEnglish(match4.Groups[1].Value, out int value4))
+            {
+                return value4;
+            }
+        }
+
+        return None;
+    }
+
+    private static bool TryParseRoman(string input, out int output)
+    {
+        switch (input?.ToLowerInvariant())
+        {
+            case "i":
+                output = 1;
+                return true;
+            case "ii":
+                output = 2;
+                return true;
+            case "iii":
+                output = 3;
+                return true;
+            case "iv":
+                output = 4;
+                return true;
+            case "v":
+                output = 5;
+                return true;
+            case "vi":
+                output = 6;
+                return true;
+            case "vii":
+                output = 7;
+                return true;
+            case "viii" or "iix":
+                output = 8;
+                return true;
+            case "ix":
+                output = 9;
+                return true;
+            case "x":
+                output = 10;
+                return true;
+            default:
+                output = 0;
+                return false;
         }
     }
-}
+
+    private static bool TryParseEnglish(string input, out int output)
+    {
+        switch (input?.ToLowerInvariant())
+        {
+            case "one":
+                output = 1;
+                return true;
+            case "two":
+                output = 2;
+                return true;
+            case "three":
+                output = 3;
+                return true;
+            case "four":
+                output = 4;
+                return true;
+            case "five":
+                output = 5;
+                return true;
+            case "six":
+                output = 6;
+                return true;
+            case "seven":
+                output = 7;
+                return true;
+            case "eight":
+                output = 8;
+                return true;
+            case "nine":
+                output = 9;
+                return true;
+            case "ten":
+                output = 10;
+                return true;
+            default:
+                output = 0;
+                return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/OrderedScheduleItemsEnumerator.cs b/ErsatzTV.Core/Scheduling/OrderedScheduleItemsEnumerator.cs
index f911a09b0..5b179b0cb 100644
--- a/ErsatzTV.Core/Scheduling/OrderedScheduleItemsEnumerator.cs
+++ b/ErsatzTV.Core/Scheduling/OrderedScheduleItemsEnumerator.cs
@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
 
 namespace ErsatzTV.Core.Scheduling;
diff --git a/ErsatzTV.Core/Scheduling/PlayoutBuilder.cs b/ErsatzTV.Core/Scheduling/PlayoutBuilder.cs
index b24b63a89..44efae4d6 100644
--- a/ErsatzTV.Core/Scheduling/PlayoutBuilder.cs
+++ b/ErsatzTV.Core/Scheduling/PlayoutBuilder.cs
@@ -1,551 +1,544 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 using Map = LanguageExt.Map;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+// TODO: these tests fail on days when offset changes
+// because the change happens during the playout
+public class PlayoutBuilder : IPlayoutBuilder
 {
-    // TODO: these tests fail on days when offset changes
-    // because the change happens during the playout
-    public class PlayoutBuilder : IPlayoutBuilder
+    private static readonly Random Random = new();
+    private readonly IArtistRepository _artistRepository;
+    private readonly ILogger<PlayoutBuilder> _logger;
+    private readonly IConfigElementRepository _configElementRepository;
+    private readonly IMediaCollectionRepository _mediaCollectionRepository;
+    private readonly ITelevisionRepository _televisionRepository;
+
+    public PlayoutBuilder(
+        IConfigElementRepository configElementRepository,
+        IMediaCollectionRepository mediaCollectionRepository,
+        ITelevisionRepository televisionRepository,
+        IArtistRepository artistRepository,
+        ILogger<PlayoutBuilder> logger)
     {
-        private static readonly Random Random = new();
-        private readonly IArtistRepository _artistRepository;
-        private readonly ILogger<PlayoutBuilder> _logger;
-        private readonly IConfigElementRepository _configElementRepository;
-        private readonly IMediaCollectionRepository _mediaCollectionRepository;
-        private readonly ITelevisionRepository _televisionRepository;
+        _configElementRepository = configElementRepository;
+        _mediaCollectionRepository = mediaCollectionRepository;
+        _televisionRepository = televisionRepository;
+        _artistRepository = artistRepository;
+        _logger = logger;
+    }
 
-        public PlayoutBuilder(
-            IConfigElementRepository configElementRepository,
-            IMediaCollectionRepository mediaCollectionRepository,
-            ITelevisionRepository televisionRepository,
-            IArtistRepository artistRepository,
-            ILogger<PlayoutBuilder> logger)
+    public async Task<Playout> BuildPlayoutItems(Playout playout, bool rebuild = false)
+    {
+        DateTimeOffset now = DateTimeOffset.Now;
+        Option<int> daysToBuild = await _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild);
+        return await BuildPlayoutItems(playout, now, now.AddDays(await daysToBuild.IfNoneAsync(2)), rebuild);
+    }
+
+    public async Task<Playout> BuildPlayoutItems(
+        Playout playout,
+        DateTimeOffset playoutStart,
+        DateTimeOffset playoutFinish,
+        bool rebuild = false)
+    {
+        Map<CollectionKey, List<MediaItem>> collectionMediaItems = await GetCollectionMediaItems(playout);
+        if (!collectionMediaItems.Any())
         {
-            _configElementRepository = configElementRepository;
-            _mediaCollectionRepository = mediaCollectionRepository;
-            _televisionRepository = televisionRepository;
-            _artistRepository = artistRepository;
-            _logger = logger;
-        }
-
-        public async Task<Playout> BuildPlayoutItems(Playout playout, bool rebuild = false)
-        {
-            DateTimeOffset now = DateTimeOffset.Now;
-            Option<int> daysToBuild = await _configElementRepository.GetValue<int>(ConfigElementKey.PlayoutDaysToBuild);
-            return await BuildPlayoutItems(playout, now, now.AddDays(await daysToBuild.IfNoneAsync(2)), rebuild);
-        }
-
-        public async Task<Playout> BuildPlayoutItems(
-            Playout playout,
-            DateTimeOffset playoutStart,
-            DateTimeOffset playoutFinish,
-            bool rebuild = false)
-        {
-            Map<CollectionKey, List<MediaItem>> collectionMediaItems = await GetCollectionMediaItems(playout);
-            if (!collectionMediaItems.Any())
-            {
-                _logger.LogWarning(
-                    "Playout {Playout} schedule {Schedule} has no items",
-                    playout.Channel.Name,
-                    playout.ProgramSchedule.Name);
-
-                return playout;
-            }
-
-            _logger.LogDebug(
-                "{Action} playout {PlayoutId} for channel {ChannelNumber} - {ChannelName}",
-                rebuild ? "Rebuilding" : "Building",
-                playout.Id,
-                playout.Channel.Number,
-                playout.Channel.Name);
-
-            Option<CollectionKey> maybeEmptyCollection = await CheckForEmptyCollections(collectionMediaItems);
-            foreach (CollectionKey emptyCollection in maybeEmptyCollection)
-            {
-                Option<string> maybeName = await _mediaCollectionRepository.GetNameFromKey(emptyCollection);
-                if (maybeName.IsSome)
-                {
-                    foreach (string name in maybeName)
-                    {
-                        _logger.LogError(
-                            "Unable to rebuild playout; {CollectionType} {CollectionName} has no valid items!",
-                            emptyCollection.CollectionType,
-                            name);
-                    }
-                }
-                else
-                {
-                    _logger.LogError(
-                        "Unable to rebuild playout; collection {@CollectionKey} has no valid items!",
-                        emptyCollection);
-                }
-
-                return playout;
-            }
-
-            playout.Items ??= new List<PlayoutItem>();
-            playout.ProgramScheduleAnchors ??= new List<PlayoutProgramScheduleAnchor>();
-
-            if (rebuild)
-            {
-                playout.Items.Clear();
-                playout.Anchor = null;
-                playout.ProgramScheduleAnchors.Clear();
-            }
-
-            var sortedScheduleItems = playout.ProgramSchedule.Items.OrderBy(i => i.Index).ToList();
-            CollectionEnumeratorState scheduleItemsEnumeratorState =
-                playout.Anchor?.ScheduleItemsEnumeratorState ?? new CollectionEnumeratorState
-                    { Seed = Random.Next(), Index = 0 };
-            IScheduleItemsEnumerator scheduleItemsEnumerator = playout.ProgramSchedule.ShuffleScheduleItems
-                ? new ShuffledScheduleItemsEnumerator(playout.ProgramSchedule.Items, scheduleItemsEnumeratorState)
-                : new OrderedScheduleItemsEnumerator(playout.ProgramSchedule.Items, scheduleItemsEnumeratorState);
-            var collectionEnumerators = new Dictionary<CollectionKey, IMediaCollectionEnumerator>();
-            foreach ((CollectionKey collectionKey, List<MediaItem> mediaItems) in collectionMediaItems)
-            {
-                // use configured playback order for primary collection, shuffle for filler
-                Option<ProgramScheduleItem> maybeScheduleItem = sortedScheduleItems
-                    .FirstOrDefault(item => CollectionKey.ForScheduleItem(item) == collectionKey);
-                PlaybackOrder playbackOrder = maybeScheduleItem
-                    .Match(item => item.PlaybackOrder, () => PlaybackOrder.Shuffle);
-                IMediaCollectionEnumerator enumerator =
-                    await GetMediaCollectionEnumerator(playout, collectionKey, mediaItems, playbackOrder);
-                collectionEnumerators.Add(collectionKey, enumerator);
-            }
-
-            // find start anchor
-            PlayoutAnchor startAnchor = FindStartAnchor(playout, playoutStart, scheduleItemsEnumerator);
-
-            // start at the previously-decided time
-            DateTimeOffset currentTime = startAnchor.NextStartOffset.ToLocalTime();
-            _logger.LogDebug(
-                "Starting playout {PlayoutId} for channel {ChannelNumber} - {ChannelName} at {StartTime}",
-                playout.Id,
-                playout.Channel.Number,
+            _logger.LogWarning(
+                "Playout {Playout} schedule {Schedule} has no items",
                 playout.Channel.Name,
-                currentTime);
-            
-            // removing any items scheduled past the start anchor
-            // this could happen if the app was closed after scheduling items
-            // but before saving the anchor
-            int removed = playout.Items.RemoveAll(pi => pi.StartOffset >= currentTime);
-            if (removed > 0)
-            {
-                _logger.LogWarning("Removed {Count} schedule items beyond current start anchor", removed);
-            }
-
-            // start with the previously-decided schedule item
-            // start with the previous multiple/duration states
-            var playoutBuilderState = new PlayoutBuilderState(
-                scheduleItemsEnumerator,
-                Optional(startAnchor.MultipleRemaining),
-                startAnchor.DurationFinishOffset,
-                startAnchor.InFlood,
-                startAnchor.InDurationFiller,
-                startAnchor.NextGuideGroup,
-                currentTime);
-
-            var schedulerOne = new PlayoutModeSchedulerOne(_logger);
-            var schedulerMultiple = new PlayoutModeSchedulerMultiple(collectionMediaItems, _logger);
-            var schedulerDuration = new PlayoutModeSchedulerDuration(_logger);
-            var schedulerFlood = new PlayoutModeSchedulerFlood(_logger);
-
-            // loop until we're done filling the desired amount of time
-            while (playoutBuilderState.CurrentTime < playoutFinish)
-            {
-                // get the schedule item out of the sorted list
-                ProgramScheduleItem scheduleItem = playoutBuilderState.ScheduleItemsEnumerator.Current;
-
-                ProgramScheduleItem nextScheduleItem = playoutBuilderState.ScheduleItemsEnumerator.Peek(1);
-
-                Tuple<PlayoutBuilderState, List<PlayoutItem>> result = scheduleItem switch
-                {
-                    ProgramScheduleItemMultiple multiple => schedulerMultiple.Schedule(
-                        playoutBuilderState,
-                        collectionEnumerators,
-                        multiple,
-                        nextScheduleItem,
-                        playoutFinish),
-                    ProgramScheduleItemDuration duration => schedulerDuration.Schedule(
-                        playoutBuilderState,
-                        collectionEnumerators,
-                        duration,
-                        nextScheduleItem,
-                        playoutFinish),
-                    ProgramScheduleItemFlood flood => schedulerFlood.Schedule(
-                        playoutBuilderState,
-                        collectionEnumerators,
-                        flood,
-                        nextScheduleItem,
-                        playoutFinish),
-                    ProgramScheduleItemOne one => schedulerOne.Schedule(
-                        playoutBuilderState,
-                        collectionEnumerators,
-                        one,
-                        nextScheduleItem,
-                        playoutFinish),
-                    _ => throw new ArgumentOutOfRangeException(nameof(scheduleItem))
-                };
-
-                (PlayoutBuilderState nextState, List<PlayoutItem> playoutItems) = result;
-
-                foreach (PlayoutItem playoutItem in playoutItems)
-                {
-                    playout.Items.Add(playoutItem);
-                }
-
-                playoutBuilderState = nextState;
-            }
-
-            // once more to get playout anchor
-            ProgramScheduleItem anchorScheduleItem = playoutBuilderState.ScheduleItemsEnumerator.Current;
-
-            // build program schedule anchors
-            playout.ProgramScheduleAnchors = BuildProgramScheduleAnchors(playout, collectionEnumerators);
-
-            // remove any items outside the desired range
-            playout.Items.RemoveAll(
-                old => old.FinishOffset < playoutStart.AddHours(-4) || old.StartOffset > playoutFinish);
-
-            if (playout.Items.Any())
-            {
-                DateTimeOffset maxStartTime = playout.Items.Max(i => i.FinishOffset);
-                if (maxStartTime < playoutBuilderState.CurrentTime)
-                {
-                    playoutBuilderState = playoutBuilderState with { CurrentTime = maxStartTime };
-                }
-            }
-
-            playout.Anchor = new PlayoutAnchor
-            {
-                ScheduleItemsEnumeratorState = playoutBuilderState.ScheduleItemsEnumerator.State,
-                NextStart = PlayoutModeSchedulerBase<ProgramScheduleItem>.GetStartTimeAfter(playoutBuilderState, anchorScheduleItem)
-                    .UtcDateTime,
-                MultipleRemaining = playoutBuilderState.MultipleRemaining.IsSome
-                    ? playoutBuilderState.MultipleRemaining.ValueUnsafe()
-                    : null,
-                DurationFinish = playoutBuilderState.DurationFinish.IsSome
-                    ? playoutBuilderState.DurationFinish.ValueUnsafe().UtcDateTime
-                    : null,
-                InFlood = playoutBuilderState.InFlood,
-                InDurationFiller = playoutBuilderState.InDurationFiller,
-                NextGuideGroup = playoutBuilderState.NextGuideGroup
-            };
+                playout.ProgramSchedule.Name);
 
             return playout;
         }
 
-        private async Task<Map<CollectionKey, List<MediaItem>>> GetCollectionMediaItems(Playout playout)
+        _logger.LogDebug(
+            "{Action} playout {PlayoutId} for channel {ChannelNumber} - {ChannelName}",
+            rebuild ? "Rebuilding" : "Building",
+            playout.Id,
+            playout.Channel.Number,
+            playout.Channel.Name);
+
+        Option<CollectionKey> maybeEmptyCollection = await CheckForEmptyCollections(collectionMediaItems);
+        foreach (CollectionKey emptyCollection in maybeEmptyCollection)
         {
-            var collectionKeys = playout.ProgramSchedule.Items
-                .SelectMany(CollectionKeysForItem)
-                .Distinct()
-                .ToList();
-
-            IEnumerable<Tuple<CollectionKey, List<MediaItem>>> tuples = await collectionKeys.Map(
-                async collectionKey => Tuple(
-                    collectionKey,
-                    await MediaItemsForCollection.Collect(
-                        _mediaCollectionRepository,
-                        _televisionRepository,
-                        _artistRepository,
-                        collectionKey))).SequenceParallel();
-
-            return Map.createRange(tuples);
-        }
-
-        private async Task<Option<CollectionKey>> CheckForEmptyCollections(
-            Map<CollectionKey, List<MediaItem>> collectionMediaItems)
-        {
-            foreach ((CollectionKey _, List<MediaItem> items) in collectionMediaItems)
+            Option<string> maybeName = await _mediaCollectionRepository.GetNameFromKey(emptyCollection);
+            if (maybeName.IsSome)
             {
-                var zeroItems = new List<MediaItem>();
-                // var missingItems = new List<MediaItem>();
-
-                foreach (MediaItem item in items)
+                foreach (string name in maybeName)
                 {
-                    bool isZero = item switch
-                    {
-                        Movie m => await m.MediaVersions.Map(v => v.Duration).HeadOrNone()
-                            .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
-                        Episode e => await e.MediaVersions.Map(v => v.Duration).HeadOrNone()
-                            .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
-                        MusicVideo mv => await mv.MediaVersions.Map(v => v.Duration).HeadOrNone()
-                            .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
-                        OtherVideo ov => await ov.MediaVersions.Map(v => v.Duration).HeadOrNone()
-                            .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
-                        Song s => await s.MediaVersions.Map(v => v.Duration).HeadOrNone()
-                            .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
-                        _ => true
-                    };
-
-                    // if (item.State == MediaItemState.FileNotFound)
-                    // {
-                    //     _logger.LogWarning(
-                    //         "Skipping media item that does not exist on disk  {MediaItem} - {MediaItemTitle} - {Path}",
-                    //         item.Id,
-                    //         DisplayTitle(item),
-                    //         item.GetHeadVersion().MediaFiles.Head().Path);
-                    //
-                    //     missingItems.Add(item);
-                    // }
-                    // else
-                    if (isZero)
-                    {
-                        _logger.LogWarning(
-                            "Skipping media item with zero duration {MediaItem} - {MediaItemTitle}",
-                            item.Id,
-                            DisplayTitle(item));
-
-                        zeroItems.Add(item);
-                    }
+                    _logger.LogError(
+                        "Unable to rebuild playout; {CollectionType} {CollectionName} has no valid items!",
+                        emptyCollection.CollectionType,
+                        name);
                 }
-
-                // items.RemoveAll(missingItems.Contains);
-                items.RemoveAll(zeroItems.Contains);
-            }
-
-            return collectionMediaItems.Find(c => !c.Value.Any()).Map(c => c.Key);
-        }
-        
-        private static PlayoutAnchor FindStartAnchor(
-            Playout playout,
-            DateTimeOffset start,
-            IScheduleItemsEnumerator enumerator) =>
-            Optional(playout.Anchor).IfNone(
-                () =>
-                {
-                    ProgramScheduleItem schedule = enumerator.Current;
-                    switch (schedule.StartType)
-                    {
-                        case StartType.Fixed:
-                            return new PlayoutAnchor
-                            {
-                                ScheduleItemsEnumeratorState = enumerator.State,
-                                NextStart = (start - start.TimeOfDay).UtcDateTime +
-                                            schedule.StartTime.GetValueOrDefault()
-                            };
-                        case StartType.Dynamic:
-                        default:
-                            return new PlayoutAnchor
-                            {
-                                ScheduleItemsEnumeratorState = enumerator.State,
-                                NextStart = (start - start.TimeOfDay).UtcDateTime
-                            };
-                    }
-                });
-
-        private static List<PlayoutProgramScheduleAnchor> BuildProgramScheduleAnchors(
-            Playout playout,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators)
-        {
-            var result = new List<PlayoutProgramScheduleAnchor>();
-
-            foreach (CollectionKey collectionKey in collectionEnumerators.Keys)
-            {
-                Option<PlayoutProgramScheduleAnchor> maybeExisting = playout.ProgramScheduleAnchors.FirstOrDefault(
-                    a => a.CollectionType == collectionKey.CollectionType
-                         && a.CollectionId == collectionKey.CollectionId
-                         && a.MediaItemId == collectionKey.MediaItemId);
-
-                var maybeEnumeratorState = collectionEnumerators.GroupBy(e => e.Key, e => e.Value.State).ToDictionary(
-                    mcs => mcs.Key,
-                    mcs => mcs.Head());
-
-                PlayoutProgramScheduleAnchor scheduleAnchor = maybeExisting.Match(
-                    existing =>
-                    {
-                        existing.EnumeratorState = maybeEnumeratorState[collectionKey];
-                        return existing;
-                    },
-                    () => new PlayoutProgramScheduleAnchor
-                    {
-                        Playout = playout,
-                        PlayoutId = playout.Id,
-                        ProgramSchedule = playout.ProgramSchedule,
-                        ProgramScheduleId = playout.ProgramScheduleId,
-                        CollectionType = collectionKey.CollectionType,
-                        CollectionId = collectionKey.CollectionId,
-                        MultiCollectionId = collectionKey.MultiCollectionId,
-                        SmartCollectionId = collectionKey.SmartCollectionId,
-                        MediaItemId = collectionKey.MediaItemId,
-                        EnumeratorState = maybeEnumeratorState[collectionKey]
-                    });
-
-                result.Add(scheduleAnchor);
-            }
-
-            return result;
-        }
-
-        private async Task<IMediaCollectionEnumerator> GetMediaCollectionEnumerator(
-            Playout playout,
-            CollectionKey collectionKey,
-            List<MediaItem> mediaItems,
-            PlaybackOrder playbackOrder)
-        {
-            Option<PlayoutProgramScheduleAnchor> maybeAnchor = playout.ProgramScheduleAnchors.FirstOrDefault(
-                a => a.ProgramScheduleId == playout.ProgramScheduleId
-                     && a.CollectionType == collectionKey.CollectionType
-                     && a.CollectionId == collectionKey.CollectionId
-                     && a.MultiCollectionId == collectionKey.MultiCollectionId
-                     && a.SmartCollectionId == collectionKey.SmartCollectionId
-                     && a.MediaItemId == collectionKey.MediaItemId);
-
-            CollectionEnumeratorState state = maybeAnchor.Match(
-                anchor => anchor.EnumeratorState ??
-                          (anchor.EnumeratorState = new CollectionEnumeratorState { Seed = Random.Next(), Index = 0 }),
-                () => new CollectionEnumeratorState { Seed = Random.Next(), Index = 0 });
-
-            if (await _mediaCollectionRepository.IsCustomPlaybackOrder(collectionKey.CollectionId ?? 0))
-            {
-                Option<Collection> collectionWithItems =
-                    await _mediaCollectionRepository.GetCollectionWithCollectionItemsUntracked(
-                        collectionKey.CollectionId ?? 0);
-
-                if (collectionKey.CollectionType == ProgramScheduleItemCollectionType.Collection &&
-                    collectionWithItems.IsSome)
-                {
-                    return new CustomOrderCollectionEnumerator(
-                        collectionWithItems.ValueUnsafe(),
-                        mediaItems,
-                        state);
-                }
-            }
-            
-            switch (playbackOrder)
-            {
-                case PlaybackOrder.Chronological:
-                    return new ChronologicalMediaCollectionEnumerator(mediaItems, state);
-                case PlaybackOrder.Random:
-                    return new RandomizedMediaCollectionEnumerator(mediaItems, state);
-                case PlaybackOrder.Shuffle:
-                    return new ShuffledMediaCollectionEnumerator(
-                        await GetGroupedMediaItemsForShuffle(playout, mediaItems, collectionKey),
-                        state);
-                case PlaybackOrder.ShuffleInOrder:
-                    return new ShuffleInOrderCollectionEnumerator(
-                        await GetCollectionItemsForShuffleInOrder(collectionKey),
-                        state);
-                default:
-                    // TODO: handle this error case differently?
-                    return new RandomizedMediaCollectionEnumerator(mediaItems, state);
-            }
-        }
-
-        private async Task<List<GroupedMediaItem>> GetGroupedMediaItemsForShuffle(
-            Playout playout,
-            List<MediaItem> mediaItems,
-            CollectionKey collectionKey)
-        {
-            if (collectionKey.MultiCollectionId != null)
-            {
-                List<CollectionWithItems> collections = await _mediaCollectionRepository
-                    .GetMultiCollectionCollections(collectionKey.MultiCollectionId.Value);
-
-                return MultiCollectionGrouper.GroupMediaItems(collections);
-            }
-
-            return playout.ProgramSchedule.KeepMultiPartEpisodesTogether
-                ? MultiPartEpisodeGrouper.GroupMediaItems(
-                    mediaItems,
-                    playout.ProgramSchedule.TreatCollectionsAsShows)
-                : mediaItems.Map(mi => new GroupedMediaItem(mi, null)).ToList();
-        }
-
-        private async Task<List<CollectionWithItems>> GetCollectionItemsForShuffleInOrder(CollectionKey collectionKey)
-        {
-            List<CollectionWithItems> result;
-
-            if (collectionKey.MultiCollectionId != null)
-            {
-                result = await _mediaCollectionRepository.GetMultiCollectionCollections(
-                    collectionKey.MultiCollectionId.Value);
             }
             else
             {
-                result = await _mediaCollectionRepository.GetFakeMultiCollectionCollections(
-                    collectionKey.CollectionId,
-                    collectionKey.SmartCollectionId);
+                _logger.LogError(
+                    "Unable to rebuild playout; collection {@CollectionKey} has no valid items!",
+                    emptyCollection);
             }
 
-            return result;
+            return playout;
         }
 
-        internal static string DisplayTitle(MediaItem mediaItem)
+        playout.Items ??= new List<PlayoutItem>();
+        playout.ProgramScheduleAnchors ??= new List<PlayoutProgramScheduleAnchor>();
+
+        if (rebuild)
         {
-            switch (mediaItem)
-            {
-                case Episode e:
-                    string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
-                        .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
-                    return e.EpisodeMetadata.HeadOrNone()
-                        .Map(em => $"{showTitle}s{e.Season.SeasonNumber:00}e{em.EpisodeNumber:00} - {em.Title}")
-                        .IfNone("[unknown episode]");
-                case Movie m:
-                    return m.MovieMetadata.HeadOrNone().Match(mm => mm.Title ?? string.Empty, () => "[unknown movie]");
-                case MusicVideo mv:
-                    string artistName = mv.Artist.ArtistMetadata.HeadOrNone()
-                        .Map(am => $"{am.Title} - ").IfNone(string.Empty);
-                    return mv.MusicVideoMetadata.HeadOrNone()
-                        .Map(mvm => $"{artistName}{mvm.Title}")
-                        .IfNone("[unknown music video]");
-                case OtherVideo ov:
-                    return ov.OtherVideoMetadata.HeadOrNone().Match(
-                        ovm => ovm.Title ?? string.Empty,
-                        () => "[unknown video]");
-                case Song s:
-                    return s.SongMetadata.HeadOrNone().Match(
-                        sm => sm.Title ?? string.Empty,
-                        () => "[unknown song]");
-                default:
-                    return string.Empty;
-            }
+            playout.Items.Clear();
+            playout.Anchor = null;
+            playout.ProgramScheduleAnchors.Clear();
         }
 
-        private static List<CollectionKey> CollectionKeysForItem(ProgramScheduleItem item)
+        var sortedScheduleItems = playout.ProgramSchedule.Items.OrderBy(i => i.Index).ToList();
+        CollectionEnumeratorState scheduleItemsEnumeratorState =
+            playout.Anchor?.ScheduleItemsEnumeratorState ?? new CollectionEnumeratorState
+                { Seed = Random.Next(), Index = 0 };
+        IScheduleItemsEnumerator scheduleItemsEnumerator = playout.ProgramSchedule.ShuffleScheduleItems
+            ? new ShuffledScheduleItemsEnumerator(playout.ProgramSchedule.Items, scheduleItemsEnumeratorState)
+            : new OrderedScheduleItemsEnumerator(playout.ProgramSchedule.Items, scheduleItemsEnumeratorState);
+        var collectionEnumerators = new Dictionary<CollectionKey, IMediaCollectionEnumerator>();
+        foreach ((CollectionKey collectionKey, List<MediaItem> mediaItems) in collectionMediaItems)
         {
-            var result = new List<CollectionKey>
+            // use configured playback order for primary collection, shuffle for filler
+            Option<ProgramScheduleItem> maybeScheduleItem = sortedScheduleItems
+                .FirstOrDefault(item => CollectionKey.ForScheduleItem(item) == collectionKey);
+            PlaybackOrder playbackOrder = maybeScheduleItem
+                .Match(item => item.PlaybackOrder, () => PlaybackOrder.Shuffle);
+            IMediaCollectionEnumerator enumerator =
+                await GetMediaCollectionEnumerator(playout, collectionKey, mediaItems, playbackOrder);
+            collectionEnumerators.Add(collectionKey, enumerator);
+        }
+
+        // find start anchor
+        PlayoutAnchor startAnchor = FindStartAnchor(playout, playoutStart, scheduleItemsEnumerator);
+
+        // start at the previously-decided time
+        DateTimeOffset currentTime = startAnchor.NextStartOffset.ToLocalTime();
+        _logger.LogDebug(
+            "Starting playout {PlayoutId} for channel {ChannelNumber} - {ChannelName} at {StartTime}",
+            playout.Id,
+            playout.Channel.Number,
+            playout.Channel.Name,
+            currentTime);
+            
+        // removing any items scheduled past the start anchor
+        // this could happen if the app was closed after scheduling items
+        // but before saving the anchor
+        int removed = playout.Items.RemoveAll(pi => pi.StartOffset >= currentTime);
+        if (removed > 0)
+        {
+            _logger.LogWarning("Removed {Count} schedule items beyond current start anchor", removed);
+        }
+
+        // start with the previously-decided schedule item
+        // start with the previous multiple/duration states
+        var playoutBuilderState = new PlayoutBuilderState(
+            scheduleItemsEnumerator,
+            Optional(startAnchor.MultipleRemaining),
+            startAnchor.DurationFinishOffset,
+            startAnchor.InFlood,
+            startAnchor.InDurationFiller,
+            startAnchor.NextGuideGroup,
+            currentTime);
+
+        var schedulerOne = new PlayoutModeSchedulerOne(_logger);
+        var schedulerMultiple = new PlayoutModeSchedulerMultiple(collectionMediaItems, _logger);
+        var schedulerDuration = new PlayoutModeSchedulerDuration(_logger);
+        var schedulerFlood = new PlayoutModeSchedulerFlood(_logger);
+
+        // loop until we're done filling the desired amount of time
+        while (playoutBuilderState.CurrentTime < playoutFinish)
+        {
+            // get the schedule item out of the sorted list
+            ProgramScheduleItem scheduleItem = playoutBuilderState.ScheduleItemsEnumerator.Current;
+
+            ProgramScheduleItem nextScheduleItem = playoutBuilderState.ScheduleItemsEnumerator.Peek(1);
+
+            Tuple<PlayoutBuilderState, List<PlayoutItem>> result = scheduleItem switch
             {
-                CollectionKey.ForScheduleItem(item)
+                ProgramScheduleItemMultiple multiple => schedulerMultiple.Schedule(
+                    playoutBuilderState,
+                    collectionEnumerators,
+                    multiple,
+                    nextScheduleItem,
+                    playoutFinish),
+                ProgramScheduleItemDuration duration => schedulerDuration.Schedule(
+                    playoutBuilderState,
+                    collectionEnumerators,
+                    duration,
+                    nextScheduleItem,
+                    playoutFinish),
+                ProgramScheduleItemFlood flood => schedulerFlood.Schedule(
+                    playoutBuilderState,
+                    collectionEnumerators,
+                    flood,
+                    nextScheduleItem,
+                    playoutFinish),
+                ProgramScheduleItemOne one => schedulerOne.Schedule(
+                    playoutBuilderState,
+                    collectionEnumerators,
+                    one,
+                    nextScheduleItem,
+                    playoutFinish),
+                _ => throw new ArgumentOutOfRangeException(nameof(scheduleItem))
             };
 
-            if (item.PreRollFiller != null)
+            (PlayoutBuilderState nextState, List<PlayoutItem> playoutItems) = result;
+
+            foreach (PlayoutItem playoutItem in playoutItems)
             {
-                result.Add(CollectionKey.ForFillerPreset(item.PreRollFiller));
+                playout.Items.Add(playoutItem);
             }
 
-            if (item.MidRollFiller != null)
+            playoutBuilderState = nextState;
+        }
+
+        // once more to get playout anchor
+        ProgramScheduleItem anchorScheduleItem = playoutBuilderState.ScheduleItemsEnumerator.Current;
+
+        // build program schedule anchors
+        playout.ProgramScheduleAnchors = BuildProgramScheduleAnchors(playout, collectionEnumerators);
+
+        // remove any items outside the desired range
+        playout.Items.RemoveAll(
+            old => old.FinishOffset < playoutStart.AddHours(-4) || old.StartOffset > playoutFinish);
+
+        if (playout.Items.Any())
+        {
+            DateTimeOffset maxStartTime = playout.Items.Max(i => i.FinishOffset);
+            if (maxStartTime < playoutBuilderState.CurrentTime)
             {
-                result.Add(CollectionKey.ForFillerPreset(item.MidRollFiller));
+                playoutBuilderState = playoutBuilderState with { CurrentTime = maxStartTime };
+            }
+        }
+
+        playout.Anchor = new PlayoutAnchor
+        {
+            ScheduleItemsEnumeratorState = playoutBuilderState.ScheduleItemsEnumerator.State,
+            NextStart = PlayoutModeSchedulerBase<ProgramScheduleItem>.GetStartTimeAfter(playoutBuilderState, anchorScheduleItem)
+                .UtcDateTime,
+            MultipleRemaining = playoutBuilderState.MultipleRemaining.IsSome
+                ? playoutBuilderState.MultipleRemaining.ValueUnsafe()
+                : null,
+            DurationFinish = playoutBuilderState.DurationFinish.IsSome
+                ? playoutBuilderState.DurationFinish.ValueUnsafe().UtcDateTime
+                : null,
+            InFlood = playoutBuilderState.InFlood,
+            InDurationFiller = playoutBuilderState.InDurationFiller,
+            NextGuideGroup = playoutBuilderState.NextGuideGroup
+        };
+
+        return playout;
+    }
+
+    private async Task<Map<CollectionKey, List<MediaItem>>> GetCollectionMediaItems(Playout playout)
+    {
+        var collectionKeys = playout.ProgramSchedule.Items
+            .SelectMany(CollectionKeysForItem)
+            .Distinct()
+            .ToList();
+
+        IEnumerable<Tuple<CollectionKey, List<MediaItem>>> tuples = await collectionKeys.Map(
+            async collectionKey => Tuple(
+                collectionKey,
+                await MediaItemsForCollection.Collect(
+                    _mediaCollectionRepository,
+                    _televisionRepository,
+                    _artistRepository,
+                    collectionKey))).SequenceParallel();
+
+        return Map.createRange(tuples);
+    }
+
+    private async Task<Option<CollectionKey>> CheckForEmptyCollections(
+        Map<CollectionKey, List<MediaItem>> collectionMediaItems)
+    {
+        foreach ((CollectionKey _, List<MediaItem> items) in collectionMediaItems)
+        {
+            var zeroItems = new List<MediaItem>();
+            // var missingItems = new List<MediaItem>();
+
+            foreach (MediaItem item in items)
+            {
+                bool isZero = item switch
+                {
+                    Movie m => await m.MediaVersions.Map(v => v.Duration).HeadOrNone()
+                        .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
+                    Episode e => await e.MediaVersions.Map(v => v.Duration).HeadOrNone()
+                        .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
+                    MusicVideo mv => await mv.MediaVersions.Map(v => v.Duration).HeadOrNone()
+                        .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
+                    OtherVideo ov => await ov.MediaVersions.Map(v => v.Duration).HeadOrNone()
+                        .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
+                    Song s => await s.MediaVersions.Map(v => v.Duration).HeadOrNone()
+                        .IfNoneAsync(TimeSpan.Zero) == TimeSpan.Zero,
+                    _ => true
+                };
+
+                // if (item.State == MediaItemState.FileNotFound)
+                // {
+                //     _logger.LogWarning(
+                //         "Skipping media item that does not exist on disk  {MediaItem} - {MediaItemTitle} - {Path}",
+                //         item.Id,
+                //         DisplayTitle(item),
+                //         item.GetHeadVersion().MediaFiles.Head().Path);
+                //
+                //     missingItems.Add(item);
+                // }
+                // else
+                if (isZero)
+                {
+                    _logger.LogWarning(
+                        "Skipping media item with zero duration {MediaItem} - {MediaItemTitle}",
+                        item.Id,
+                        DisplayTitle(item));
+
+                    zeroItems.Add(item);
+                }
             }
 
-            if (item.PostRollFiller != null)
-            {
-                result.Add(CollectionKey.ForFillerPreset(item.PostRollFiller));
-            }
+            // items.RemoveAll(missingItems.Contains);
+            items.RemoveAll(zeroItems.Contains);
+        }
 
-            if (item.TailFiller != null)
+        return collectionMediaItems.Find(c => !c.Value.Any()).Map(c => c.Key);
+    }
+        
+    private static PlayoutAnchor FindStartAnchor(
+        Playout playout,
+        DateTimeOffset start,
+        IScheduleItemsEnumerator enumerator) =>
+        Optional(playout.Anchor).IfNone(
+            () =>
             {
-                result.Add(CollectionKey.ForFillerPreset(item.TailFiller));
-            }
+                ProgramScheduleItem schedule = enumerator.Current;
+                switch (schedule.StartType)
+                {
+                    case StartType.Fixed:
+                        return new PlayoutAnchor
+                        {
+                            ScheduleItemsEnumeratorState = enumerator.State,
+                            NextStart = (start - start.TimeOfDay).UtcDateTime +
+                                        schedule.StartTime.GetValueOrDefault()
+                        };
+                    case StartType.Dynamic:
+                    default:
+                        return new PlayoutAnchor
+                        {
+                            ScheduleItemsEnumeratorState = enumerator.State,
+                            NextStart = (start - start.TimeOfDay).UtcDateTime
+                        };
+                }
+            });
 
-            if (item.FallbackFiller != null)
+    private static List<PlayoutProgramScheduleAnchor> BuildProgramScheduleAnchors(
+        Playout playout,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators)
+    {
+        var result = new List<PlayoutProgramScheduleAnchor>();
+
+        foreach (CollectionKey collectionKey in collectionEnumerators.Keys)
+        {
+            Option<PlayoutProgramScheduleAnchor> maybeExisting = playout.ProgramScheduleAnchors.FirstOrDefault(
+                a => a.CollectionType == collectionKey.CollectionType
+                     && a.CollectionId == collectionKey.CollectionId
+                     && a.MediaItemId == collectionKey.MediaItemId);
+
+            var maybeEnumeratorState = collectionEnumerators.GroupBy(e => e.Key, e => e.Value.State).ToDictionary(
+                mcs => mcs.Key,
+                mcs => mcs.Head());
+
+            PlayoutProgramScheduleAnchor scheduleAnchor = maybeExisting.Match(
+                existing =>
+                {
+                    existing.EnumeratorState = maybeEnumeratorState[collectionKey];
+                    return existing;
+                },
+                () => new PlayoutProgramScheduleAnchor
+                {
+                    Playout = playout,
+                    PlayoutId = playout.Id,
+                    ProgramSchedule = playout.ProgramSchedule,
+                    ProgramScheduleId = playout.ProgramScheduleId,
+                    CollectionType = collectionKey.CollectionType,
+                    CollectionId = collectionKey.CollectionId,
+                    MultiCollectionId = collectionKey.MultiCollectionId,
+                    SmartCollectionId = collectionKey.SmartCollectionId,
+                    MediaItemId = collectionKey.MediaItemId,
+                    EnumeratorState = maybeEnumeratorState[collectionKey]
+                });
+
+            result.Add(scheduleAnchor);
+        }
+
+        return result;
+    }
+
+    private async Task<IMediaCollectionEnumerator> GetMediaCollectionEnumerator(
+        Playout playout,
+        CollectionKey collectionKey,
+        List<MediaItem> mediaItems,
+        PlaybackOrder playbackOrder)
+    {
+        Option<PlayoutProgramScheduleAnchor> maybeAnchor = playout.ProgramScheduleAnchors.FirstOrDefault(
+            a => a.ProgramScheduleId == playout.ProgramScheduleId
+                 && a.CollectionType == collectionKey.CollectionType
+                 && a.CollectionId == collectionKey.CollectionId
+                 && a.MultiCollectionId == collectionKey.MultiCollectionId
+                 && a.SmartCollectionId == collectionKey.SmartCollectionId
+                 && a.MediaItemId == collectionKey.MediaItemId);
+
+        CollectionEnumeratorState state = maybeAnchor.Match(
+            anchor => anchor.EnumeratorState ??
+                      (anchor.EnumeratorState = new CollectionEnumeratorState { Seed = Random.Next(), Index = 0 }),
+            () => new CollectionEnumeratorState { Seed = Random.Next(), Index = 0 });
+
+        if (await _mediaCollectionRepository.IsCustomPlaybackOrder(collectionKey.CollectionId ?? 0))
+        {
+            Option<Collection> collectionWithItems =
+                await _mediaCollectionRepository.GetCollectionWithCollectionItemsUntracked(
+                    collectionKey.CollectionId ?? 0);
+
+            if (collectionKey.CollectionType == ProgramScheduleItemCollectionType.Collection &&
+                collectionWithItems.IsSome)
             {
-                result.Add(CollectionKey.ForFillerPreset(item.FallbackFiller));
+                return new CustomOrderCollectionEnumerator(
+                    collectionWithItems.ValueUnsafe(),
+                    mediaItems,
+                    state);
             }
-
-            return result;
+        }
+            
+        switch (playbackOrder)
+        {
+            case PlaybackOrder.Chronological:
+                return new ChronologicalMediaCollectionEnumerator(mediaItems, state);
+            case PlaybackOrder.Random:
+                return new RandomizedMediaCollectionEnumerator(mediaItems, state);
+            case PlaybackOrder.Shuffle:
+                return new ShuffledMediaCollectionEnumerator(
+                    await GetGroupedMediaItemsForShuffle(playout, mediaItems, collectionKey),
+                    state);
+            case PlaybackOrder.ShuffleInOrder:
+                return new ShuffleInOrderCollectionEnumerator(
+                    await GetCollectionItemsForShuffleInOrder(collectionKey),
+                    state);
+            default:
+                // TODO: handle this error case differently?
+                return new RandomizedMediaCollectionEnumerator(mediaItems, state);
         }
     }
-}
+
+    private async Task<List<GroupedMediaItem>> GetGroupedMediaItemsForShuffle(
+        Playout playout,
+        List<MediaItem> mediaItems,
+        CollectionKey collectionKey)
+    {
+        if (collectionKey.MultiCollectionId != null)
+        {
+            List<CollectionWithItems> collections = await _mediaCollectionRepository
+                .GetMultiCollectionCollections(collectionKey.MultiCollectionId.Value);
+
+            return MultiCollectionGrouper.GroupMediaItems(collections);
+        }
+
+        return playout.ProgramSchedule.KeepMultiPartEpisodesTogether
+            ? MultiPartEpisodeGrouper.GroupMediaItems(
+                mediaItems,
+                playout.ProgramSchedule.TreatCollectionsAsShows)
+            : mediaItems.Map(mi => new GroupedMediaItem(mi, null)).ToList();
+    }
+
+    private async Task<List<CollectionWithItems>> GetCollectionItemsForShuffleInOrder(CollectionKey collectionKey)
+    {
+        List<CollectionWithItems> result;
+
+        if (collectionKey.MultiCollectionId != null)
+        {
+            result = await _mediaCollectionRepository.GetMultiCollectionCollections(
+                collectionKey.MultiCollectionId.Value);
+        }
+        else
+        {
+            result = await _mediaCollectionRepository.GetFakeMultiCollectionCollections(
+                collectionKey.CollectionId,
+                collectionKey.SmartCollectionId);
+        }
+
+        return result;
+    }
+
+    internal static string DisplayTitle(MediaItem mediaItem)
+    {
+        switch (mediaItem)
+        {
+            case Episode e:
+                string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
+                    .Map(sm => $"{sm.Title} - ").IfNone(string.Empty);
+                return e.EpisodeMetadata.HeadOrNone()
+                    .Map(em => $"{showTitle}s{e.Season.SeasonNumber:00}e{em.EpisodeNumber:00} - {em.Title}")
+                    .IfNone("[unknown episode]");
+            case Movie m:
+                return m.MovieMetadata.HeadOrNone().Match(mm => mm.Title ?? string.Empty, () => "[unknown movie]");
+            case MusicVideo mv:
+                string artistName = mv.Artist.ArtistMetadata.HeadOrNone()
+                    .Map(am => $"{am.Title} - ").IfNone(string.Empty);
+                return mv.MusicVideoMetadata.HeadOrNone()
+                    .Map(mvm => $"{artistName}{mvm.Title}")
+                    .IfNone("[unknown music video]");
+            case OtherVideo ov:
+                return ov.OtherVideoMetadata.HeadOrNone().Match(
+                    ovm => ovm.Title ?? string.Empty,
+                    () => "[unknown video]");
+            case Song s:
+                return s.SongMetadata.HeadOrNone().Match(
+                    sm => sm.Title ?? string.Empty,
+                    () => "[unknown song]");
+            default:
+                return string.Empty;
+        }
+    }
+
+    private static List<CollectionKey> CollectionKeysForItem(ProgramScheduleItem item)
+    {
+        var result = new List<CollectionKey>
+        {
+            CollectionKey.ForScheduleItem(item)
+        };
+
+        if (item.PreRollFiller != null)
+        {
+            result.Add(CollectionKey.ForFillerPreset(item.PreRollFiller));
+        }
+
+        if (item.MidRollFiller != null)
+        {
+            result.Add(CollectionKey.ForFillerPreset(item.MidRollFiller));
+        }
+
+        if (item.PostRollFiller != null)
+        {
+            result.Add(CollectionKey.ForFillerPreset(item.PostRollFiller));
+        }
+
+        if (item.TailFiller != null)
+        {
+            result.Add(CollectionKey.ForFillerPreset(item.TailFiller));
+        }
+
+        if (item.FallbackFiller != null)
+        {
+            result.Add(CollectionKey.ForFillerPreset(item.FallbackFiller));
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/PlayoutBuilderState.cs b/ErsatzTV.Core/Scheduling/PlayoutBuilderState.cs
index 9f5130f54..7857bfed2 100644
--- a/ErsatzTV.Core/Scheduling/PlayoutBuilderState.cs
+++ b/ErsatzTV.Core/Scheduling/PlayoutBuilderState.cs
@@ -1,19 +1,16 @@
-using System;
-using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
+using ErsatzTV.Core.Interfaces.Scheduling;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public record PlayoutBuilderState(
+    IScheduleItemsEnumerator ScheduleItemsEnumerator,
+    Option<int> MultipleRemaining,
+    Option<DateTimeOffset> DurationFinish,
+    bool InFlood,
+    bool InDurationFiller,
+    int NextGuideGroup,
+    DateTimeOffset CurrentTime)
 {
-    public record PlayoutBuilderState(
-        IScheduleItemsEnumerator ScheduleItemsEnumerator,
-        Option<int> MultipleRemaining,
-        Option<DateTimeOffset> DurationFinish,
-        bool InFlood,
-        bool InDurationFiller,
-        int NextGuideGroup,
-        DateTimeOffset CurrentTime)
-    {
-        public int IncrementGuideGroup => (NextGuideGroup + 1) % 10000;
-        public int DecrementGuideGroup => (NextGuideGroup - 1) % 10000;
-    }
-}
+    public int IncrementGuideGroup => (NextGuideGroup + 1) % 10000;
+    public int DecrementGuideGroup => (NextGuideGroup - 1) % 10000;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/PlayoutModeBlock.cs b/ErsatzTV.Core/Scheduling/PlayoutModeBlock.cs
index e4470b93b..20cfd7993 100644
--- a/ErsatzTV.Core/Scheduling/PlayoutModeBlock.cs
+++ b/ErsatzTV.Core/Scheduling/PlayoutModeBlock.cs
@@ -1,6 +1,3 @@
-using System;
+namespace ErsatzTV.Core.Scheduling;
 
-namespace ErsatzTV.Core.Scheduling
-{
-    public record PlayoutModeBlock(DateTimeOffset StartTime, DateTimeOffset FinishTime);
-}
+public record PlayoutModeBlock(DateTimeOffset StartTime, DateTimeOffset FinishTime);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerBase.cs b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerBase.cs
index 1e6e6852f..ca91c10d4 100644
--- a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerBase.cs
+++ b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerBase.cs
@@ -1,597 +1,630 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
-using LanguageExt;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public abstract class PlayoutModeSchedulerBase<T> : IPlayoutModeScheduler<T> where T : ProgramScheduleItem
 {
-    public abstract class PlayoutModeSchedulerBase<T> : IPlayoutModeScheduler<T> where T : ProgramScheduleItem
+    protected readonly ILogger _logger;
+
+    protected PlayoutModeSchedulerBase(ILogger logger)
     {
-        protected readonly ILogger _logger;
+        _logger = logger;
+    }
 
-        protected PlayoutModeSchedulerBase(ILogger logger)
-        {
-            _logger = logger;
-        }
+    public static DateTimeOffset GetStartTimeAfter(
+        PlayoutBuilderState state,
+        ProgramScheduleItem scheduleItem)
+    {
+        DateTimeOffset startTime = state.CurrentTime;
 
-        public static DateTimeOffset GetStartTimeAfter(
-            PlayoutBuilderState state,
-            ProgramScheduleItem scheduleItem)
-        {
-            DateTimeOffset startTime = state.CurrentTime;
-
-            bool isIncomplete = scheduleItem is ProgramScheduleItemMultiple && state.MultipleRemaining.IsSome ||
-                                scheduleItem is ProgramScheduleItemDuration && state.DurationFinish.IsSome ||
-                                scheduleItem is ProgramScheduleItemFlood && state.InFlood ||
-                                scheduleItem is ProgramScheduleItemDuration && state.InDurationFiller;
+        bool isIncomplete = scheduleItem is ProgramScheduleItemMultiple && state.MultipleRemaining.IsSome ||
+                            scheduleItem is ProgramScheduleItemDuration && state.DurationFinish.IsSome ||
+                            scheduleItem is ProgramScheduleItemFlood && state.InFlood ||
+                            scheduleItem is ProgramScheduleItemDuration && state.InDurationFiller;
             
-            if (scheduleItem.StartType == StartType.Fixed && !isIncomplete)
-            {
-                TimeSpan itemStartTime = scheduleItem.StartTime.GetValueOrDefault();
-                DateTime date = startTime.Date;
-                DateTimeOffset result = new DateTimeOffset(
-                        date.Year,
-                        date.Month,
-                        date.Day,
-                        0,
-                        0,
-                        0,
-                        TimeZoneInfo.Local.GetUtcOffset(
-                            new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, DateTimeKind.Local)))
-                    .Add(itemStartTime);
+        if (scheduleItem.StartType == StartType.Fixed && !isIncomplete)
+        {
+            TimeSpan itemStartTime = scheduleItem.StartTime.GetValueOrDefault();
+            DateTime date = startTime.Date;
+            DateTimeOffset result = new DateTimeOffset(
+                    date.Year,
+                    date.Month,
+                    date.Day,
+                    0,
+                    0,
+                    0,
+                    TimeZoneInfo.Local.GetUtcOffset(
+                        new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, DateTimeKind.Local)))
+                .Add(itemStartTime);
                 
-                // DateTimeOffset result = startTime.Date + itemStartTime;
-                // need to wrap to the next day if appropriate
-                startTime = startTime.TimeOfDay > itemStartTime ? result.AddDays(1) : result;
-            }
-
-            return startTime;
+            // DateTimeOffset result = startTime.Date + itemStartTime;
+            // need to wrap to the next day if appropriate
+            startTime = startTime.TimeOfDay > itemStartTime ? result.AddDays(1) : result;
         }
 
-        public abstract Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
-            T scheduleItem,
-            ProgramScheduleItem nextScheduleItem,
-            DateTimeOffset hardStop);
+        return startTime;
+    }
 
-        protected Tuple<PlayoutBuilderState, List<PlayoutItem>> AddTailFiller(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
-            ProgramScheduleItem scheduleItem,
-            List<PlayoutItem> playoutItems,
-            DateTimeOffset nextItemStart)
+    public abstract Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+        T scheduleItem,
+        ProgramScheduleItem nextScheduleItem,
+        DateTimeOffset hardStop);
+
+    protected Tuple<PlayoutBuilderState, List<PlayoutItem>> AddTailFiller(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+        ProgramScheduleItem scheduleItem,
+        List<PlayoutItem> playoutItems,
+        DateTimeOffset nextItemStart)
+    {
+        var newItems = new List<PlayoutItem>(playoutItems);
+        PlayoutBuilderState nextState = playoutBuilderState;
+
+        if (scheduleItem.TailFiller != null)
         {
-            var newItems = new List<PlayoutItem>(playoutItems);
-            PlayoutBuilderState nextState = playoutBuilderState;
+            IMediaCollectionEnumerator enumerator =
+                collectionEnumerators[CollectionKey.ForFillerPreset(scheduleItem.TailFiller)];
 
-            if (scheduleItem.TailFiller != null)
+            while (enumerator.Current.IsSome && nextState.CurrentTime < nextItemStart)
             {
-                IMediaCollectionEnumerator enumerator =
-                    collectionEnumerators[CollectionKey.ForFillerPreset(scheduleItem.TailFiller)];
+                MediaItem mediaItem = enumerator.Current.ValueUnsafe();
 
-                while (enumerator.Current.IsSome && nextState.CurrentTime < nextItemStart)
+                TimeSpan itemDuration = DurationForMediaItem(mediaItem);
+
+                if (nextState.CurrentTime + itemDuration > nextItemStart)
                 {
-                    MediaItem mediaItem = enumerator.Current.ValueUnsafe();
+                    _logger.LogDebug(
+                        "Filler with duration {Duration} will go past next item start {NextItemStart}",
+                        itemDuration,
+                        nextItemStart);
 
-                    TimeSpan itemDuration = DurationForMediaItem(mediaItem);
-
-                    if (nextState.CurrentTime + itemDuration > nextItemStart)
-                    {
-                        _logger.LogDebug(
-                            "Filler with duration {Duration} will go past next item start {NextItemStart}",
-                            itemDuration,
-                            nextItemStart);
-
-                        break;
-                    }
+                    break;
+                }
                     
-                    var playoutItem = new PlayoutItem
-                    {
-                        MediaItemId = mediaItem.Id,
-                        Start = nextState.CurrentTime.UtcDateTime,
-                        Finish = nextState.CurrentTime.UtcDateTime + itemDuration,
-                        InPoint = TimeSpan.Zero,
-                        OutPoint = itemDuration,
-                        FillerKind = FillerKind.Tail,
-                        GuideGroup = nextState.NextGuideGroup
-                    };
+                var playoutItem = new PlayoutItem
+                {
+                    MediaItemId = mediaItem.Id,
+                    Start = nextState.CurrentTime.UtcDateTime,
+                    Finish = nextState.CurrentTime.UtcDateTime + itemDuration,
+                    InPoint = TimeSpan.Zero,
+                    OutPoint = itemDuration,
+                    FillerKind = FillerKind.Tail,
+                    GuideGroup = nextState.NextGuideGroup
+                };
 
-                    newItems.Add(playoutItem);
+                newItems.Add(playoutItem);
 
-                    nextState = nextState with
-                    {
-                        CurrentTime = nextState.CurrentTime + itemDuration
-                    };
+                nextState = nextState with
+                {
+                    CurrentTime = nextState.CurrentTime + itemDuration
+                };
 
-                    enumerator.MoveNext();
-                }
+                enumerator.MoveNext();
             }
-
-            return Tuple(nextState, newItems);
         }
+
+        return Tuple(nextState, newItems);
+    }
         
-        protected Tuple<PlayoutBuilderState, List<PlayoutItem>> AddFallbackFiller(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
-            ProgramScheduleItem scheduleItem,
-            List<PlayoutItem> playoutItems,
-            DateTimeOffset nextItemStart)
-        {
-            var newItems = new List<PlayoutItem>(playoutItems);
-            PlayoutBuilderState nextState = playoutBuilderState;
+    protected Tuple<PlayoutBuilderState, List<PlayoutItem>> AddFallbackFiller(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+        ProgramScheduleItem scheduleItem,
+        List<PlayoutItem> playoutItems,
+        DateTimeOffset nextItemStart)
+    {
+        var newItems = new List<PlayoutItem>(playoutItems);
+        PlayoutBuilderState nextState = playoutBuilderState;
 
-            if (scheduleItem.FallbackFiller != null && playoutBuilderState.CurrentTime < nextItemStart)
+        if (scheduleItem.FallbackFiller != null && playoutBuilderState.CurrentTime < nextItemStart)
+        {
+            IMediaCollectionEnumerator enumerator =
+                collectionEnumerators[CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller)];
+
+            foreach (MediaItem mediaItem in enumerator.Current)
             {
-                IMediaCollectionEnumerator enumerator =
-                    collectionEnumerators[CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller)];
-
-                foreach (MediaItem mediaItem in enumerator.Current)
+                var playoutItem = new PlayoutItem
                 {
-                    var playoutItem = new PlayoutItem
-                    {
-                        MediaItemId = mediaItem.Id,
-                        Start = nextState.CurrentTime.UtcDateTime,
-                        Finish = nextItemStart.UtcDateTime,
-                        InPoint = TimeSpan.Zero,
-                        OutPoint = TimeSpan.Zero,
-                        GuideGroup = nextState.NextGuideGroup,
-                        FillerKind = FillerKind.Fallback
-                    };
+                    MediaItemId = mediaItem.Id,
+                    Start = nextState.CurrentTime.UtcDateTime,
+                    Finish = nextItemStart.UtcDateTime,
+                    InPoint = TimeSpan.Zero,
+                    OutPoint = TimeSpan.Zero,
+                    GuideGroup = nextState.NextGuideGroup,
+                    FillerKind = FillerKind.Fallback
+                };
 
-                    newItems.Add(playoutItem);
+                newItems.Add(playoutItem);
 
-                    nextState = nextState with
-                    {
-                        CurrentTime = nextItemStart.UtcDateTime
-                    };
+                nextState = nextState with
+                {
+                    CurrentTime = nextItemStart.UtcDateTime
+                };
 
-                    enumerator.MoveNext();
-                }
+                enumerator.MoveNext();
             }
-
-            return Tuple(nextState, newItems);
         }
 
-        protected static TimeSpan DurationForMediaItem(MediaItem mediaItem)
-        {
-            MediaVersion version = mediaItem.GetHeadVersion();
-            return version.Duration;
-        }
+        return Tuple(nextState, newItems);
+    }
 
-        protected static List<MediaChapter> ChaptersForMediaItem(MediaItem mediaItem)
-        {
-            MediaVersion version = mediaItem.GetHeadVersion();
-            return version.Chapters;
-        }
+    protected static TimeSpan DurationForMediaItem(MediaItem mediaItem)
+    {
+        MediaVersion version = mediaItem.GetHeadVersion();
+        return version.Duration;
+    }
 
-        protected void LogScheduledItem(
-            ProgramScheduleItem scheduleItem,
-            MediaItem mediaItem,
-            DateTimeOffset startTime) =>
-            _logger.LogDebug(
-                "Scheduling media item: {ScheduleItemNumber} / {CollectionType} / {MediaItemId} - {MediaItemTitle} / {StartTime}",
-                scheduleItem.Index,
-                scheduleItem.CollectionType,
-                mediaItem.Id,
-                PlayoutBuilder.DisplayTitle(mediaItem),
-                startTime);
+    protected static List<MediaChapter> ChaptersForMediaItem(MediaItem mediaItem)
+    {
+        MediaVersion version = mediaItem.GetHeadVersion();
+        return version.Chapters;
+    }
 
-        internal static DateTimeOffset CalculateEndTimeWithFiller(
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> enumerators,
-            ProgramScheduleItem scheduleItem,
-            DateTimeOffset itemStartTime,
-            TimeSpan itemDuration,
-            List<MediaChapter> chapters)
-        {
-            var allFiller = Optional(scheduleItem.PreRollFiller)
-                .Append(Optional(scheduleItem.MidRollFiller))
-                .Append(Optional(scheduleItem.PostRollFiller))
-                .ToList();
+    protected void LogScheduledItem(
+        ProgramScheduleItem scheduleItem,
+        MediaItem mediaItem,
+        DateTimeOffset startTime) =>
+        _logger.LogDebug(
+            "Scheduling media item: {ScheduleItemNumber} / {CollectionType} / {MediaItemId} - {MediaItemTitle} / {StartTime}",
+            scheduleItem.Index,
+            scheduleItem.CollectionType,
+            mediaItem.Id,
+            PlayoutBuilder.DisplayTitle(mediaItem),
+            startTime);
 
-            if (allFiller.Count(f => f.PadToNearestMinute.HasValue) > 1)
+    internal static DateTimeOffset CalculateEndTimeWithFiller(
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> enumerators,
+        ProgramScheduleItem scheduleItem,
+        DateTimeOffset itemStartTime,
+        TimeSpan itemDuration,
+        List<MediaChapter> chapters)
+    {
+        var allFiller = Optional(scheduleItem.PreRollFiller)
+            .Append(Optional(scheduleItem.MidRollFiller))
+            .Append(Optional(scheduleItem.PostRollFiller))
+            .ToList();
+
+        if (allFiller.Count(f => f.PadToNearestMinute.HasValue) > 1)
             // if (allFiller.Map(f => Optional(f.PadToNearestMinute)).Sequence().Flatten().Distinct().Count() > 1)
+        {
+            // multiple pad-to-nearest-minute values are invalid; use no filler
+            // TODO: log error?
+            return itemStartTime + itemDuration;
+        }
+
+        TimeSpan totalDuration = itemDuration;
+        foreach (FillerPreset filler in allFiller)
+        {
+            switch (filler.FillerKind, filler.FillerMode)
             {
-                // multiple pad-to-nearest-minute values are invalid; use no filler
-                // TODO: log error?
-                return itemStartTime + itemDuration;
-            }
-
-            TimeSpan totalDuration = itemDuration;
-            foreach (FillerPreset filler in allFiller)
-            {
-                switch (filler.FillerKind, filler.FillerMode)
-                {
-                    case (FillerKind.MidRoll, FillerMode.Duration) when filler.Duration.HasValue:
-                        IMediaCollectionEnumerator mrde = enumerators[CollectionKey.ForFillerPreset(filler)];
-                        var mrdePeekOffset = 0;
-                        for (var i = 0; i < chapters.Count - 1; i++)
+                case (FillerKind.MidRoll, FillerMode.Duration) when filler.Duration.HasValue:
+                    IMediaCollectionEnumerator mrde = enumerators[CollectionKey.ForFillerPreset(filler)];
+                    var mrdePeekOffset = 0;
+                    for (var i = 0; i < chapters.Count - 1; i++)
+                    {
+                        TimeSpan midRollDuration = filler.Duration.Value;
+                        while (mrde.Peek(mrdePeekOffset))
                         {
-                            TimeSpan midRollDuration = filler.Duration.Value;
-                            while (mrde.Peek(mrdePeekOffset))
-                            {
-                                foreach (MediaItem mediaItem in mrde.Peek(mrdePeekOffset))
-                                {
-                                    TimeSpan currentDuration = DurationForMediaItem(mediaItem);
-                                    midRollDuration -= currentDuration;
-                                    if (midRollDuration >= TimeSpan.Zero)
-                                    {
-                                        totalDuration += currentDuration;
-                                        mrdePeekOffset++;
-                                    }
-                                }
-
-                                if (midRollDuration < TimeSpan.Zero)
-                                {
-                                    break;
-                                }
-                            }
-                        }
-
-                        break;
-                    case (FillerKind.MidRoll, FillerMode.Count) when filler.Count.HasValue:
-                        IMediaCollectionEnumerator mrce = enumerators[CollectionKey.ForFillerPreset(filler)];
-                        var mrcePeekOffset = 0;
-                        for (var i = 0; i < chapters.Count - 1; i++)
-                        {
-                            for (var j = 0; j < filler.Count.Value; j++)
-                            {
-                                foreach (MediaItem mediaItem in mrce.Peek(mrcePeekOffset))
-                                {
-                                    totalDuration += DurationForMediaItem(mediaItem);
-                                    mrcePeekOffset++;
-                                }
-                            }
-                        }
-
-                        break;
-                    case (_, FillerMode.Duration) when filler.Duration.HasValue:
-                        IMediaCollectionEnumerator e1 = enumerators[CollectionKey.ForFillerPreset(filler)];
-                        var peekOffset1 = 0;
-                        TimeSpan duration = filler.Duration.Value;
-                        while (e1.Peek(peekOffset1).IsSome)
-                        {
-                            foreach (MediaItem mediaItem in e1.Peek(peekOffset1))
+                            foreach (MediaItem mediaItem in mrde.Peek(mrdePeekOffset))
                             {
                                 TimeSpan currentDuration = DurationForMediaItem(mediaItem);
-                                duration -= currentDuration;
-                                if (duration >= TimeSpan.Zero)
+                                midRollDuration -= currentDuration;
+                                if (midRollDuration >= TimeSpan.Zero)
                                 {
                                     totalDuration += currentDuration;
-                                    peekOffset1++;
+                                    mrdePeekOffset++;
                                 }
                             }
 
-                            if (duration < TimeSpan.Zero)
+                            if (midRollDuration < TimeSpan.Zero)
                             {
                                 break;
                             }
                         }
+                    }
 
-                        break;
-                    case (_, FillerMode.Count) when filler.Count.HasValue:
-                        IMediaCollectionEnumerator e2 = enumerators[CollectionKey.ForFillerPreset(filler)];
-                        var peekOffset2 = 0;
-                        for (var i = 0; i < filler.Count.Value; i++)
+                    break;
+                case (FillerKind.MidRoll, FillerMode.Count) when filler.Count.HasValue:
+                    IMediaCollectionEnumerator mrce = enumerators[CollectionKey.ForFillerPreset(filler)];
+                    var mrcePeekOffset = 0;
+                    for (var i = 0; i < chapters.Count - 1; i++)
+                    {
+                        for (var j = 0; j < filler.Count.Value; j++)
                         {
-                            foreach (MediaItem mediaItem in e2.Peek(peekOffset2))
+                            foreach (MediaItem mediaItem in mrce.Peek(mrcePeekOffset))
                             {
                                 totalDuration += DurationForMediaItem(mediaItem);
-                                peekOffset2++;
+                                mrcePeekOffset++;
+                            }
+                        }
+                    }
+
+                    break;
+                case (_, FillerMode.Duration) when filler.Duration.HasValue:
+                    IMediaCollectionEnumerator e1 = enumerators[CollectionKey.ForFillerPreset(filler)];
+                    var peekOffset1 = 0;
+                    TimeSpan duration = filler.Duration.Value;
+                    while (e1.Peek(peekOffset1).IsSome)
+                    {
+                        foreach (MediaItem mediaItem in e1.Peek(peekOffset1))
+                        {
+                            TimeSpan currentDuration = DurationForMediaItem(mediaItem);
+                            duration -= currentDuration;
+                            if (duration >= TimeSpan.Zero)
+                            {
+                                totalDuration += currentDuration;
+                                peekOffset1++;
                             }
                         }
 
-                        break;
-                }
-            }
+                        if (duration < TimeSpan.Zero)
+                        {
+                            break;
+                        }
+                    }
 
-            foreach (FillerPreset padFiller in Optional(allFiller.FirstOrDefault(f => f.PadToNearestMinute.HasValue)))
-            {
-                int currentMinute = (itemStartTime + totalDuration).Minute;
-                // ReSharper disable once PossibleInvalidOperationException
-                int targetMinute = (currentMinute + padFiller.PadToNearestMinute.Value - 1) /
-                    padFiller.PadToNearestMinute.Value * padFiller.PadToNearestMinute.Value;
-                
-                DateTimeOffset targetTime = itemStartTime + totalDuration - TimeSpan.FromMinutes(currentMinute) +
-                                            TimeSpan.FromMinutes(targetMinute);
-                
-                return new DateTimeOffset(
-                    targetTime.Year,
-                    targetTime.Month,
-                    targetTime.Day,
-                    targetTime.Hour,
-                    targetTime.Minute,
-                    0,
-                    targetTime.Offset);
-            }
+                    break;
+                case (_, FillerMode.Count) when filler.Count.HasValue:
+                    IMediaCollectionEnumerator e2 = enumerators[CollectionKey.ForFillerPreset(filler)];
+                    var peekOffset2 = 0;
+                    for (var i = 0; i < filler.Count.Value; i++)
+                    {
+                        foreach (MediaItem mediaItem in e2.Peek(peekOffset2))
+                        {
+                            totalDuration += DurationForMediaItem(mediaItem);
+                            peekOffset2++;
+                        }
+                    }
 
-            return itemStartTime + totalDuration;
+                    break;
+            }
         }
 
-        protected List<PlayoutItem> AddFiller(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> enumerators,
-            ProgramScheduleItem scheduleItem,
-            PlayoutItem playoutItem,
-            List<MediaChapter> chapters)
+        foreach (FillerPreset padFiller in Optional(allFiller.FirstOrDefault(f => f.PadToNearestMinute.HasValue)))
         {
-            var result = new List<PlayoutItem>();
-            
-            var allFiller = Optional(scheduleItem.PreRollFiller)
-                .Append(Optional(scheduleItem.MidRollFiller))
-                .Append(Optional(scheduleItem.PostRollFiller))
-                .ToList();
+            int currentMinute = (itemStartTime + totalDuration).Minute;
+            // ReSharper disable once PossibleInvalidOperationException
+            int targetMinute = (currentMinute + padFiller.PadToNearestMinute.Value - 1) /
+                padFiller.PadToNearestMinute.Value * padFiller.PadToNearestMinute.Value;
+                
+            DateTimeOffset targetTime = itemStartTime + totalDuration - TimeSpan.FromMinutes(currentMinute) +
+                                        TimeSpan.FromMinutes(targetMinute);
+                
+            return new DateTimeOffset(
+                targetTime.Year,
+                targetTime.Month,
+                targetTime.Day,
+                targetTime.Hour,
+                targetTime.Minute,
+                0,
+                targetTime.Offset);
+        }
 
-            if (allFiller.Count(f => f.PadToNearestMinute.HasValue) > 1)
+        return itemStartTime + totalDuration;
+    }
+
+    protected List<PlayoutItem> AddFiller(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> enumerators,
+        ProgramScheduleItem scheduleItem,
+        PlayoutItem playoutItem,
+        List<MediaChapter> chapters)
+    {
+        var result = new List<PlayoutItem>();
+            
+        var allFiller = Optional(scheduleItem.PreRollFiller)
+            .Append(Optional(scheduleItem.MidRollFiller))
+            .Append(Optional(scheduleItem.PostRollFiller))
+            .ToList();
+
+        if (allFiller.Count(f => f.PadToNearestMinute.HasValue) > 1)
             // if (allFiller.Map(f => Optional(f.PadToNearestMinute)).Sequence().Flatten().Distinct().Count() > 1)
-            {
-                // multiple pad-to-nearest-minute values are invalid; use no filler
-                // TODO: log error?
-                return new List<PlayoutItem> { playoutItem };
-            }
+        {
+            // multiple pad-to-nearest-minute values are invalid; use no filler
+            // TODO: log error?
+            return new List<PlayoutItem> { playoutItem };
+        }
 
-            List<MediaChapter> effectiveChapters = chapters;
-            if (allFiller.All(fp => fp.FillerKind != FillerKind.MidRoll))
-            {
-                effectiveChapters = new List<MediaChapter>();
-            }
+        List<MediaChapter> effectiveChapters = chapters;
+        if (allFiller.All(fp => fp.FillerKind != FillerKind.MidRoll))
+        {
+            effectiveChapters = new List<MediaChapter>();
+        }
 
+        foreach (FillerPreset filler in allFiller.Filter(
+                     f => f.FillerKind == FillerKind.PreRoll && f.FillerMode != FillerMode.Pad))
+        {
+            switch (filler.FillerMode)
+            {
+                case FillerMode.Duration when filler.Duration.HasValue:
+                    IMediaCollectionEnumerator e1 = enumerators[CollectionKey.ForFillerPreset(filler)];
+                    result.AddRange(
+                        AddDurationFiller(playoutBuilderState, e1, filler.Duration.Value, FillerKind.PreRoll));
+                    break;
+                case FillerMode.Count when filler.Count.HasValue:
+                    IMediaCollectionEnumerator e2 = enumerators[CollectionKey.ForFillerPreset(filler)];
+                    result.AddRange(
+                        AddCountFiller(playoutBuilderState, e2, filler.Count.Value, FillerKind.PreRoll));
+                    break;
+            }
+        }
+
+        if (!effectiveChapters.Any())
+        {
+            result.Add(playoutItem);
+        }
+        else
+        {
             foreach (FillerPreset filler in allFiller.Filter(
-                f => f.FillerKind == FillerKind.PreRoll && f.FillerMode != FillerMode.Pad))
+                         f => f.FillerKind == FillerKind.MidRoll && f.FillerMode != FillerMode.Pad))
             {
                 switch (filler.FillerMode)
                 {
                     case FillerMode.Duration when filler.Duration.HasValue:
                         IMediaCollectionEnumerator e1 = enumerators[CollectionKey.ForFillerPreset(filler)];
-                        result.AddRange(
-                            AddDurationFiller(playoutBuilderState, e1, filler.Duration.Value, FillerKind.PreRoll));
-                        break;
-                    case FillerMode.Count when filler.Count.HasValue:
-                        IMediaCollectionEnumerator e2 = enumerators[CollectionKey.ForFillerPreset(filler)];
-                        result.AddRange(
-                            AddCountFiller(playoutBuilderState, e2, filler.Count.Value, FillerKind.PreRoll));
-                        break;
-                }
-            }
-
-            if (!effectiveChapters.Any())
-            {
-                result.Add(playoutItem);
-            }
-            else
-            {
-                foreach (FillerPreset filler in allFiller.Filter(
-                    f => f.FillerKind == FillerKind.MidRoll && f.FillerMode != FillerMode.Pad))
-                {
-                    switch (filler.FillerMode)
-                    {
-                        case FillerMode.Duration when filler.Duration.HasValue:
-                            IMediaCollectionEnumerator e1 = enumerators[CollectionKey.ForFillerPreset(filler)];
-                            for (var i = 0; i < effectiveChapters.Count; i++)
-                            {
-                                result.Add(playoutItem.ForChapter(effectiveChapters[i]));
-                                if (i < effectiveChapters.Count - 1)
-                                {
-                                    result.AddRange(
-                                        AddDurationFiller(
-                                            playoutBuilderState,
-                                            e1,
-                                            filler.Duration.Value,
-                                            FillerKind.MidRoll));
-                                }
-                            }
-
-                            break;
-                        case FillerMode.Count when filler.Count.HasValue:
-                            IMediaCollectionEnumerator e2 = enumerators[CollectionKey.ForFillerPreset(filler)];
-                            for (var i = 0; i < effectiveChapters.Count - 1; i++)
-                            {
-                                result.Add(playoutItem.ForChapter(effectiveChapters[i]));
-                                result.AddRange(
-                                    AddCountFiller(
-                                        playoutBuilderState,
-                                        e2,
-                                        filler.Count.Value,
-                                        FillerKind.MidRoll));
-                            }
-
-                            break;
-                    }
-                }
-            }
-
-            foreach (FillerPreset filler in allFiller.Filter(
-                f => f.FillerKind == FillerKind.PostRoll && f.FillerMode != FillerMode.Pad))
-            {
-                switch (filler.FillerMode)
-                {
-                    case FillerMode.Duration when filler.Duration.HasValue:
-                        IMediaCollectionEnumerator e1 = enumerators[CollectionKey.ForFillerPreset(filler)];
-                        result.AddRange(
-                            AddDurationFiller(playoutBuilderState, e1, filler.Duration.Value, FillerKind.PostRoll));
-                        break;
-                    case FillerMode.Count when filler.Count.HasValue:
-                        IMediaCollectionEnumerator e2 = enumerators[CollectionKey.ForFillerPreset(filler)];
-                        result.AddRange(
-                            AddCountFiller(playoutBuilderState, e2, filler.Count.Value, FillerKind.PostRoll));
-                        break;
-                }
-            }
-            
-            // after all non-padded filler has been added, figure out padding
-            foreach (FillerPreset padFiller in Optional(allFiller.FirstOrDefault(f => f.PadToNearestMinute.HasValue)))
-            {
-                var totalDuration =
-                    TimeSpan.FromMilliseconds(
-                        result.Sum(pi => (pi.Finish - pi.Start).TotalMilliseconds) +
-                        effectiveChapters.Sum(c => (c.EndTime - c.StartTime).TotalMilliseconds));
-                
-                int currentMinute = (playoutItem.StartOffset + totalDuration).Minute;
-                // ReSharper disable once PossibleInvalidOperationException
-                int targetMinute = (currentMinute + padFiller.PadToNearestMinute.Value - 1) /
-                    padFiller.PadToNearestMinute.Value * padFiller.PadToNearestMinute.Value;
-
-                DateTimeOffset almostTargetTime = playoutItem.StartOffset + totalDuration -
-                                            TimeSpan.FromMinutes(currentMinute) +
-                                            TimeSpan.FromMinutes(targetMinute);
-
-                
-                var targetTime = new DateTimeOffset(
-                    almostTargetTime.Year,
-                    almostTargetTime.Month,
-                    almostTargetTime.Day,
-                    almostTargetTime.Hour,
-                    almostTargetTime.Minute,
-                    0,
-                    almostTargetTime.Offset);
-
-                TimeSpan remainingToFill = targetTime - totalDuration - playoutItem.StartOffset;
-
-                // _logger.LogInformation(
-                //     "Total duration {TotalDuration}; need to fill {TimeSpan} to pad properly to {TargetTime}",
-                //     totalDuration,
-                //     remainingToFill,
-                //     targetTime);
-
-                switch (padFiller.FillerKind)
-                {
-                    case FillerKind.PreRoll:
-                        IMediaCollectionEnumerator pre1 = enumerators[CollectionKey.ForFillerPreset(padFiller)];
-                        result.InsertRange(
-                            0,
-                            AddDurationFiller(
-                                playoutBuilderState,
-                                pre1,
-                                remainingToFill,
-                                FillerKind.PreRoll));
-                        totalDuration =
-                            TimeSpan.FromMilliseconds(result.Sum(pi => (pi.Finish - pi.Start).TotalMilliseconds));
-                        remainingToFill = targetTime - totalDuration - playoutItem.StartOffset;
-                        if (remainingToFill > TimeSpan.Zero)
-                        {
-                            result.InsertRange(
-                                0,
-                                FallbackFillerForPad(
-                                    playoutBuilderState,
-                                    enumerators,
-                                    scheduleItem,
-                                    remainingToFill));
-                        }
-
-                        break;
-                    case FillerKind.MidRoll:
-                        IMediaCollectionEnumerator mid1 = enumerators[CollectionKey.ForFillerPreset(padFiller)];
-                        var fillerQueue = new Queue<PlayoutItem>(
-                            AddDurationFiller(
-                                playoutBuilderState,
-                                mid1,
-                                remainingToFill,
-                                FillerKind.MidRoll));
-                        TimeSpan average = effectiveChapters.Count == 0
-                            ? remainingToFill
-                            : remainingToFill / (effectiveChapters.Count - 1);
-                        TimeSpan filled = TimeSpan.Zero;
-                        for (var i = 0; i < chapters.Count; i++)
+                        for (var i = 0; i < effectiveChapters.Count; i++)
                         {
                             result.Add(playoutItem.ForChapter(effectiveChapters[i]));
                             if (i < effectiveChapters.Count - 1)
                             {
-                                TimeSpan current = TimeSpan.Zero;
-                                while (current < average && filled < remainingToFill)
-                                {
-                                    if (fillerQueue.TryDequeue(out PlayoutItem fillerItem))
-                                    {
-                                        result.Add(fillerItem);
-                                        current += fillerItem.Finish - fillerItem.Start;
-                                        filled += fillerItem.Finish - fillerItem.Start;
-                                    }
-                                    else
-                                    {
-                                        TimeSpan leftInThisBreak = average - current;
-                                        TimeSpan leftOverall = remainingToFill - filled;
-
-                                        TimeSpan maxThisBreak = leftOverall < leftInThisBreak
-                                            ? leftOverall
-                                            : leftInThisBreak;
-
-                                        Option<PlayoutItem> maybeFallback = FallbackFillerForPad(
-                                            playoutBuilderState,
-                                            enumerators,
-                                            scheduleItem,
-                                            i < effectiveChapters.Count - 1 ? maxThisBreak : leftOverall);
-
-                                        foreach (PlayoutItem fallback in maybeFallback)
-                                        {
-                                            current += fallback.Finish - fallback.Start;
-                                            filled += fallback.Finish - fallback.Start;
-                                            result.Add(fallback);
-                                        }
-                                    }
-                                }
+                                result.AddRange(
+                                    AddDurationFiller(
+                                        playoutBuilderState,
+                                        e1,
+                                        filler.Duration.Value,
+                                        FillerKind.MidRoll));
                             }
                         }
-                        
+
                         break;
-                    case FillerKind.PostRoll:
-                        IMediaCollectionEnumerator post1 = enumerators[CollectionKey.ForFillerPreset(padFiller)];
-                        result.AddRange(
-                            AddDurationFiller(
-                                playoutBuilderState,
-                                post1,
-                                remainingToFill,
-                                FillerKind.PostRoll));
-                        totalDuration =
-                            TimeSpan.FromMilliseconds(result.Sum(pi => (pi.Finish - pi.Start).TotalMilliseconds));
-                        remainingToFill = targetTime - totalDuration - playoutItem.StartOffset;
-                        if (remainingToFill > TimeSpan.Zero)
+                    case FillerMode.Count when filler.Count.HasValue:
+                        IMediaCollectionEnumerator e2 = enumerators[CollectionKey.ForFillerPreset(filler)];
+                        for (var i = 0; i < effectiveChapters.Count - 1; i++)
                         {
+                            result.Add(playoutItem.ForChapter(effectiveChapters[i]));
                             result.AddRange(
-                                FallbackFillerForPad(
+                                AddCountFiller(
                                     playoutBuilderState,
-                                    enumerators,
-                                    scheduleItem,
-                                    remainingToFill));
+                                    e2,
+                                    filler.Count.Value,
+                                    FillerKind.MidRoll));
                         }
 
                         break;
                 }
             }
-
-            // fix times on each playout item
-            DateTimeOffset currentTime = playoutItem.StartOffset;
-            for (var i = 0; i < result.Count; i++)
-            {
-                PlayoutItem item = result[i];
-                TimeSpan duration = item.Finish - item.Start;
-                item.Start = currentTime.UtcDateTime;
-                item.Finish = (currentTime + duration).UtcDateTime;
-                currentTime = item.FinishOffset;
-            }
-
-            return result;
         }
 
-        private static List<PlayoutItem> AddCountFiller(
-            PlayoutBuilderState playoutBuilderState,
-            IMediaCollectionEnumerator enumerator,
-            int count,
-            FillerKind fillerKind)
+        foreach (FillerPreset filler in allFiller.Filter(
+                     f => f.FillerKind == FillerKind.PostRoll && f.FillerMode != FillerMode.Pad))
         {
-            var result = new List<PlayoutItem>();
-
-            for (var i = 0; i < count; i++)
+            switch (filler.FillerMode)
             {
-                foreach (MediaItem mediaItem in enumerator.Current)
-                {
-                    TimeSpan itemDuration = DurationForMediaItem(mediaItem);
+                case FillerMode.Duration when filler.Duration.HasValue:
+                    IMediaCollectionEnumerator e1 = enumerators[CollectionKey.ForFillerPreset(filler)];
+                    result.AddRange(
+                        AddDurationFiller(playoutBuilderState, e1, filler.Duration.Value, FillerKind.PostRoll));
+                    break;
+                case FillerMode.Count when filler.Count.HasValue:
+                    IMediaCollectionEnumerator e2 = enumerators[CollectionKey.ForFillerPreset(filler)];
+                    result.AddRange(
+                        AddCountFiller(playoutBuilderState, e2, filler.Count.Value, FillerKind.PostRoll));
+                    break;
+            }
+        }
+            
+        // after all non-padded filler has been added, figure out padding
+        foreach (FillerPreset padFiller in Optional(allFiller.FirstOrDefault(f => f.PadToNearestMinute.HasValue)))
+        {
+            var totalDuration =
+                TimeSpan.FromMilliseconds(
+                    result.Sum(pi => (pi.Finish - pi.Start).TotalMilliseconds) +
+                    effectiveChapters.Sum(c => (c.EndTime - c.StartTime).TotalMilliseconds));
+                
+            int currentMinute = (playoutItem.StartOffset + totalDuration).Minute;
+            // ReSharper disable once PossibleInvalidOperationException
+            int targetMinute = (currentMinute + padFiller.PadToNearestMinute.Value - 1) /
+                padFiller.PadToNearestMinute.Value * padFiller.PadToNearestMinute.Value;
 
+            DateTimeOffset almostTargetTime = playoutItem.StartOffset + totalDuration -
+                                              TimeSpan.FromMinutes(currentMinute) +
+                                              TimeSpan.FromMinutes(targetMinute);
+
+                
+            var targetTime = new DateTimeOffset(
+                almostTargetTime.Year,
+                almostTargetTime.Month,
+                almostTargetTime.Day,
+                almostTargetTime.Hour,
+                almostTargetTime.Minute,
+                0,
+                almostTargetTime.Offset);
+
+            TimeSpan remainingToFill = targetTime - totalDuration - playoutItem.StartOffset;
+
+            // _logger.LogInformation(
+            //     "Total duration {TotalDuration}; need to fill {TimeSpan} to pad properly to {TargetTime}",
+            //     totalDuration,
+            //     remainingToFill,
+            //     targetTime);
+
+            switch (padFiller.FillerKind)
+            {
+                case FillerKind.PreRoll:
+                    IMediaCollectionEnumerator pre1 = enumerators[CollectionKey.ForFillerPreset(padFiller)];
+                    result.InsertRange(
+                        0,
+                        AddDurationFiller(
+                            playoutBuilderState,
+                            pre1,
+                            remainingToFill,
+                            FillerKind.PreRoll));
+                    totalDuration =
+                        TimeSpan.FromMilliseconds(result.Sum(pi => (pi.Finish - pi.Start).TotalMilliseconds));
+                    remainingToFill = targetTime - totalDuration - playoutItem.StartOffset;
+                    if (remainingToFill > TimeSpan.Zero)
+                    {
+                        result.InsertRange(
+                            0,
+                            FallbackFillerForPad(
+                                playoutBuilderState,
+                                enumerators,
+                                scheduleItem,
+                                remainingToFill));
+                    }
+
+                    break;
+                case FillerKind.MidRoll:
+                    IMediaCollectionEnumerator mid1 = enumerators[CollectionKey.ForFillerPreset(padFiller)];
+                    var fillerQueue = new Queue<PlayoutItem>(
+                        AddDurationFiller(
+                            playoutBuilderState,
+                            mid1,
+                            remainingToFill,
+                            FillerKind.MidRoll));
+                    TimeSpan average = effectiveChapters.Count == 0
+                        ? remainingToFill
+                        : remainingToFill / (effectiveChapters.Count - 1);
+                    TimeSpan filled = TimeSpan.Zero;
+                    for (var i = 0; i < chapters.Count; i++)
+                    {
+                        result.Add(playoutItem.ForChapter(effectiveChapters[i]));
+                        if (i < effectiveChapters.Count - 1)
+                        {
+                            TimeSpan current = TimeSpan.Zero;
+                            while (current < average && filled < remainingToFill)
+                            {
+                                if (fillerQueue.TryDequeue(out PlayoutItem fillerItem))
+                                {
+                                    result.Add(fillerItem);
+                                    current += fillerItem.Finish - fillerItem.Start;
+                                    filled += fillerItem.Finish - fillerItem.Start;
+                                }
+                                else
+                                {
+                                    TimeSpan leftInThisBreak = average - current;
+                                    TimeSpan leftOverall = remainingToFill - filled;
+
+                                    TimeSpan maxThisBreak = leftOverall < leftInThisBreak
+                                        ? leftOverall
+                                        : leftInThisBreak;
+
+                                    Option<PlayoutItem> maybeFallback = FallbackFillerForPad(
+                                        playoutBuilderState,
+                                        enumerators,
+                                        scheduleItem,
+                                        i < effectiveChapters.Count - 1 ? maxThisBreak : leftOverall);
+
+                                    foreach (PlayoutItem fallback in maybeFallback)
+                                    {
+                                        current += fallback.Finish - fallback.Start;
+                                        filled += fallback.Finish - fallback.Start;
+                                        result.Add(fallback);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                        
+                    break;
+                case FillerKind.PostRoll:
+                    IMediaCollectionEnumerator post1 = enumerators[CollectionKey.ForFillerPreset(padFiller)];
+                    result.AddRange(
+                        AddDurationFiller(
+                            playoutBuilderState,
+                            post1,
+                            remainingToFill,
+                            FillerKind.PostRoll));
+                    totalDuration =
+                        TimeSpan.FromMilliseconds(result.Sum(pi => (pi.Finish - pi.Start).TotalMilliseconds));
+                    remainingToFill = targetTime - totalDuration - playoutItem.StartOffset;
+                    if (remainingToFill > TimeSpan.Zero)
+                    {
+                        result.AddRange(
+                            FallbackFillerForPad(
+                                playoutBuilderState,
+                                enumerators,
+                                scheduleItem,
+                                remainingToFill));
+                    }
+
+                    break;
+            }
+        }
+
+        // fix times on each playout item
+        DateTimeOffset currentTime = playoutItem.StartOffset;
+        for (var i = 0; i < result.Count; i++)
+        {
+            PlayoutItem item = result[i];
+            TimeSpan duration = item.Finish - item.Start;
+            item.Start = currentTime.UtcDateTime;
+            item.Finish = (currentTime + duration).UtcDateTime;
+            currentTime = item.FinishOffset;
+        }
+
+        return result;
+    }
+
+    private static List<PlayoutItem> AddCountFiller(
+        PlayoutBuilderState playoutBuilderState,
+        IMediaCollectionEnumerator enumerator,
+        int count,
+        FillerKind fillerKind)
+    {
+        var result = new List<PlayoutItem>();
+
+        for (var i = 0; i < count; i++)
+        {
+            foreach (MediaItem mediaItem in enumerator.Current)
+            {
+                TimeSpan itemDuration = DurationForMediaItem(mediaItem);
+
+                var playoutItem = new PlayoutItem
+                {
+                    MediaItemId = mediaItem.Id,
+                    Start = new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc),
+                    Finish = new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc) + itemDuration,
+                    InPoint = TimeSpan.Zero,
+                    OutPoint = itemDuration,
+                    GuideGroup = playoutBuilderState.NextGuideGroup,
+                    FillerKind = fillerKind
+                };
+
+                result.Add(playoutItem);
+                enumerator.MoveNext();
+            }
+        }
+
+        return result;
+    }
+
+    private static List<PlayoutItem> AddDurationFiller(
+        PlayoutBuilderState playoutBuilderState,
+        IMediaCollectionEnumerator enumerator,
+        TimeSpan duration,
+        FillerKind fillerKind)
+    {
+        var result = new List<PlayoutItem>();
+            
+        while (enumerator.Current.IsSome)
+        {
+            foreach (MediaItem mediaItem in enumerator.Current)
+            {
+                // TODO: retry up to x times when item doesn't fit?
+                    
+                TimeSpan itemDuration = DurationForMediaItem(mediaItem);
+                duration -= itemDuration;
+
+                if (duration >= TimeSpan.Zero)
+                {
                     var playoutItem = new PlayoutItem
                     {
                         MediaItemId = mediaItem.Id,
@@ -608,84 +641,45 @@ namespace ErsatzTV.Core.Scheduling
                 }
             }
 
-            return result;
-        }
-
-        private static List<PlayoutItem> AddDurationFiller(
-            PlayoutBuilderState playoutBuilderState,
-            IMediaCollectionEnumerator enumerator,
-            TimeSpan duration,
-            FillerKind fillerKind)
-        {
-            var result = new List<PlayoutItem>();
-            
-            while (enumerator.Current.IsSome)
+            if (duration < TimeSpan.Zero)
             {
-                foreach (MediaItem mediaItem in enumerator.Current)
-                {
-                    // TODO: retry up to x times when item doesn't fit?
-                    
-                    TimeSpan itemDuration = DurationForMediaItem(mediaItem);
-                    duration -= itemDuration;
-
-                    if (duration >= TimeSpan.Zero)
-                    {
-                        var playoutItem = new PlayoutItem
-                        {
-                            MediaItemId = mediaItem.Id,
-                            Start = new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc),
-                            Finish = new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc) + itemDuration,
-                            InPoint = TimeSpan.Zero,
-                            OutPoint = itemDuration,
-                            GuideGroup = playoutBuilderState.NextGuideGroup,
-                            FillerKind = fillerKind
-                        };
-
-                        result.Add(playoutItem);
-                        enumerator.MoveNext();
-                    }
-                }
-
-                if (duration < TimeSpan.Zero)
-                {
-                    break;
-                }
+                break;
             }
-
-            return result;
         }
 
-        private Option<PlayoutItem> FallbackFillerForPad(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> enumerators,
-            ProgramScheduleItem scheduleItem,
-            TimeSpan duration)
-        {
-            if (scheduleItem.FallbackFiller != null)
-            {
-                IMediaCollectionEnumerator enumerator =
-                    enumerators[CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller)];
-
-                foreach (MediaItem mediaItem in enumerator.Current)
-                {
-                    var result = new PlayoutItem
-                    {
-                        MediaItemId = mediaItem.Id,
-                        Start = new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc),
-                        Finish = new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc) + duration,
-                        InPoint = TimeSpan.Zero,
-                        OutPoint = TimeSpan.Zero,
-                        GuideGroup = playoutBuilderState.NextGuideGroup,
-                        FillerKind = FillerKind.Fallback
-                    };
-
-                    enumerator.MoveNext();
-
-                    return result;
-                }
-            }
-
-            return None;
-        }
+        return result;
     }
-}
+
+    private Option<PlayoutItem> FallbackFillerForPad(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> enumerators,
+        ProgramScheduleItem scheduleItem,
+        TimeSpan duration)
+    {
+        if (scheduleItem.FallbackFiller != null)
+        {
+            IMediaCollectionEnumerator enumerator =
+                enumerators[CollectionKey.ForFillerPreset(scheduleItem.FallbackFiller)];
+
+            foreach (MediaItem mediaItem in enumerator.Current)
+            {
+                var result = new PlayoutItem
+                {
+                    MediaItemId = mediaItem.Id,
+                    Start = new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc),
+                    Finish = new DateTime(2020, 2, 1, 0, 0, 0, DateTimeKind.Utc) + duration,
+                    InPoint = TimeSpan.Zero,
+                    OutPoint = TimeSpan.Zero,
+                    GuideGroup = playoutBuilderState.NextGuideGroup,
+                    FillerKind = FillerKind.Fallback
+                };
+
+                enumerator.MoveNext();
+
+                return result;
+            }
+        }
+
+        return None;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerDuration.cs b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerDuration.cs
index 692a22057..fbe566083 100644
--- a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerDuration.cs
+++ b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerDuration.cs
@@ -1,137 +1,120 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class PlayoutModeSchedulerDuration : PlayoutModeSchedulerBase<ProgramScheduleItemDuration>
 {
-    public class PlayoutModeSchedulerDuration : PlayoutModeSchedulerBase<ProgramScheduleItemDuration>
+    public PlayoutModeSchedulerDuration(ILogger logger) : base(logger)
     {
-        public PlayoutModeSchedulerDuration(ILogger logger) : base(logger)
+    }
+
+    public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+        ProgramScheduleItemDuration scheduleItem,
+        ProgramScheduleItem nextScheduleItem,
+        DateTimeOffset hardStop)
+    {
+        var playoutItems = new List<PlayoutItem>();
+
+        PlayoutBuilderState nextState = playoutBuilderState;
+
+        var willFinishInTime = true;
+        Option<DateTimeOffset> durationUntil = None;
+
+        IMediaCollectionEnumerator contentEnumerator =
+            collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
+        while (contentEnumerator.Current.IsSome && nextState.CurrentTime < hardStop && willFinishInTime)
         {
-        }
+            MediaItem mediaItem = contentEnumerator.Current.ValueUnsafe();
 
-        public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
-            ProgramScheduleItemDuration scheduleItem,
-            ProgramScheduleItem nextScheduleItem,
-            DateTimeOffset hardStop)
-        {
-            var playoutItems = new List<PlayoutItem>();
+            // find when we should start this item, based on the current time
+            DateTimeOffset itemStartTime = GetStartTimeAfter(nextState, scheduleItem);
 
-            PlayoutBuilderState nextState = playoutBuilderState;
-
-            var willFinishInTime = true;
-            Option<DateTimeOffset> durationUntil = None;
-
-            IMediaCollectionEnumerator contentEnumerator =
-                collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
-            while (contentEnumerator.Current.IsSome && nextState.CurrentTime < hardStop && willFinishInTime)
+            // remember when we need to finish this duration item
+            if (nextState.DurationFinish.IsNone)
             {
-                MediaItem mediaItem = contentEnumerator.Current.ValueUnsafe();
-
-                // find when we should start this item, based on the current time
-                DateTimeOffset itemStartTime = GetStartTimeAfter(nextState, scheduleItem);
-
-                // remember when we need to finish this duration item
-                if (nextState.DurationFinish.IsNone)
+                nextState = nextState with
                 {
-                    nextState = nextState with
-                    {
-                        DurationFinish = itemStartTime + scheduleItem.PlayoutDuration
-                    };
-
-                    durationUntil = nextState.DurationFinish;
-                }
-
-                TimeSpan itemDuration = DurationForMediaItem(mediaItem);
-                List<MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
-
-                if (itemDuration > scheduleItem.PlayoutDuration)
-                {
-                    _logger.LogWarning(
-                        "Skipping playout item {Title} with duration {Duration} that is longer than schedule item duration {PlayoutDuration}",
-                        PlayoutBuilder.DisplayTitle(mediaItem),
-                        itemDuration,
-                        scheduleItem.PlayoutDuration);
-
-                    contentEnumerator.MoveNext();
-                    continue;
-                }
-
-                var playoutItem = new PlayoutItem
-                {
-                    MediaItemId = mediaItem.Id,
-                    Start = itemStartTime.UtcDateTime,
-                    Finish = itemStartTime.UtcDateTime + itemDuration,
-                    InPoint = TimeSpan.Zero,
-                    OutPoint = itemDuration,
-                    GuideGroup = nextState.NextGuideGroup,
-                    FillerKind = scheduleItem.GuideMode == GuideMode.Filler
-                        ? FillerKind.Tail
-                        : FillerKind.None,
-                    CustomTitle = scheduleItem.CustomTitle
+                    DurationFinish = itemStartTime + scheduleItem.PlayoutDuration
                 };
-                
-                durationUntil.Do(du => playoutItem.GuideFinish = du.UtcDateTime); 
-                
-                DateTimeOffset durationFinish = nextState.DurationFinish.IfNone(SystemTime.MaxValueUtc);
-                DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
-                    collectionEnumerators,
-                    scheduleItem,
-                    itemStartTime,
-                    itemDuration,
-                    itemChapters);
-                willFinishInTime = itemStartTime > durationFinish ||
-                                   itemEndTimeWithFiller <= durationFinish;
-                if (willFinishInTime)
-                {
-                    // LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
-                    playoutItems.AddRange(
-                        AddFiller(nextState, collectionEnumerators, scheduleItem, playoutItem, itemChapters));
 
-                    nextState = nextState with
-                    {
-                        CurrentTime = itemEndTimeWithFiller,
-
-                        // only bump guide group if we don't have a custom title
-                        NextGuideGroup = string.IsNullOrWhiteSpace(scheduleItem.CustomTitle)
-                            ? nextState.IncrementGuideGroup
-                            : nextState.NextGuideGroup
-                    };
-
-                    contentEnumerator.MoveNext();
-                }
-                else
-                {
-                    TimeSpan durationBlock = itemEndTimeWithFiller - itemStartTime;
-                    if (itemEndTimeWithFiller - itemStartTime > scheduleItem.PlayoutDuration)
-                    {
-                        _logger.LogWarning(
-                            "Unable to schedule duration block of {DurationBlock} which is longer than the configured playout duration {PlayoutDuration}",
-                            durationBlock,
-                            scheduleItem.PlayoutDuration);
-                    }
-
-                    nextState = nextState with
-                    {
-                        DurationFinish = None
-                    };
-
-                    nextState.ScheduleItemsEnumerator.MoveNext();
-                }
+                durationUntil = nextState.DurationFinish;
             }
 
-            // this is needed when the duration finish exactly matches the hard stop
-            if (nextState.DurationFinish.IsSome && nextState.CurrentTime == nextState.DurationFinish)
+            TimeSpan itemDuration = DurationForMediaItem(mediaItem);
+            List<MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
+
+            if (itemDuration > scheduleItem.PlayoutDuration)
             {
+                _logger.LogWarning(
+                    "Skipping playout item {Title} with duration {Duration} that is longer than schedule item duration {PlayoutDuration}",
+                    PlayoutBuilder.DisplayTitle(mediaItem),
+                    itemDuration,
+                    scheduleItem.PlayoutDuration);
+
+                contentEnumerator.MoveNext();
+                continue;
+            }
+
+            var playoutItem = new PlayoutItem
+            {
+                MediaItemId = mediaItem.Id,
+                Start = itemStartTime.UtcDateTime,
+                Finish = itemStartTime.UtcDateTime + itemDuration,
+                InPoint = TimeSpan.Zero,
+                OutPoint = itemDuration,
+                GuideGroup = nextState.NextGuideGroup,
+                FillerKind = scheduleItem.GuideMode == GuideMode.Filler
+                    ? FillerKind.Tail
+                    : FillerKind.None,
+                CustomTitle = scheduleItem.CustomTitle
+            };
+                
+            durationUntil.Do(du => playoutItem.GuideFinish = du.UtcDateTime); 
+                
+            DateTimeOffset durationFinish = nextState.DurationFinish.IfNone(SystemTime.MaxValueUtc);
+            DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
+                collectionEnumerators,
+                scheduleItem,
+                itemStartTime,
+                itemDuration,
+                itemChapters);
+            willFinishInTime = itemStartTime > durationFinish ||
+                               itemEndTimeWithFiller <= durationFinish;
+            if (willFinishInTime)
+            {
+                // LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
+                playoutItems.AddRange(
+                    AddFiller(nextState, collectionEnumerators, scheduleItem, playoutItem, itemChapters));
+
+                nextState = nextState with
+                {
+                    CurrentTime = itemEndTimeWithFiller,
+
+                    // only bump guide group if we don't have a custom title
+                    NextGuideGroup = string.IsNullOrWhiteSpace(scheduleItem.CustomTitle)
+                        ? nextState.IncrementGuideGroup
+                        : nextState.NextGuideGroup
+                };
+
+                contentEnumerator.MoveNext();
+            }
+            else
+            {
+                TimeSpan durationBlock = itemEndTimeWithFiller - itemStartTime;
+                if (itemEndTimeWithFiller - itemStartTime > scheduleItem.PlayoutDuration)
+                {
+                    _logger.LogWarning(
+                        "Unable to schedule duration block of {DurationBlock} which is longer than the configured playout duration {PlayoutDuration}",
+                        durationBlock,
+                        scheduleItem.PlayoutDuration);
+                }
+
                 nextState = nextState with
                 {
                     DurationFinish = None
@@ -139,66 +122,77 @@ namespace ErsatzTV.Core.Scheduling
 
                 nextState.ScheduleItemsEnumerator.MoveNext();
             }
-
-            if (playoutItems.Select(pi => pi.GuideGroup).Distinct().Count() != 1)
-            {
-                nextState = nextState with { NextGuideGroup = nextState.DecrementGuideGroup };
-            }
-
-            foreach (DateTimeOffset nextItemStart in durationUntil)
-            {
-                switch (scheduleItem.TailMode)
-                {
-                    case TailMode.Filler:
-                        if (scheduleItem.TailFiller != null)
-                        {
-                            (nextState, playoutItems) = AddTailFiller(
-                                nextState,
-                                collectionEnumerators,
-                                scheduleItem,
-                                playoutItems,
-                                nextItemStart);
-                        }
-
-                        if (scheduleItem.FallbackFiller != null)
-                        {
-                            (nextState, playoutItems) = AddFallbackFiller(
-                                nextState,
-                                collectionEnumerators,
-                                scheduleItem,
-                                playoutItems,
-                                nextItemStart);
-                        }
-
-                        nextState = nextState with { CurrentTime = nextItemStart };
-                        break;
-                    case TailMode.Offline:
-                        if (scheduleItem.FallbackFiller != null)
-                        {
-                            (nextState, playoutItems) = AddFallbackFiller(
-                                nextState,
-                                collectionEnumerators,
-                                scheduleItem,
-                                playoutItems,
-                                nextItemStart);
-                        }
-
-                        nextState = nextState with { CurrentTime = nextItemStart };
-                        break;
-                }
-            }
-
-            // clear guide finish on all but the last item
-            var all = playoutItems.Filter(pi => pi.FillerKind == FillerKind.None).ToList();
-            PlayoutItem last = all.OrderBy(pi => pi.FinishOffset).LastOrDefault();
-            foreach (PlayoutItem item in all.Filter(pi => pi != last))
-            {
-                item.GuideFinish = null;
-            }
-
-            nextState = nextState with { NextGuideGroup = nextState.IncrementGuideGroup };
-            
-            return Tuple(nextState, playoutItems);
         }
+
+        // this is needed when the duration finish exactly matches the hard stop
+        if (nextState.DurationFinish.IsSome && nextState.CurrentTime == nextState.DurationFinish)
+        {
+            nextState = nextState with
+            {
+                DurationFinish = None
+            };
+
+            nextState.ScheduleItemsEnumerator.MoveNext();
+        }
+
+        if (playoutItems.Select(pi => pi.GuideGroup).Distinct().Count() != 1)
+        {
+            nextState = nextState with { NextGuideGroup = nextState.DecrementGuideGroup };
+        }
+
+        foreach (DateTimeOffset nextItemStart in durationUntil)
+        {
+            switch (scheduleItem.TailMode)
+            {
+                case TailMode.Filler:
+                    if (scheduleItem.TailFiller != null)
+                    {
+                        (nextState, playoutItems) = AddTailFiller(
+                            nextState,
+                            collectionEnumerators,
+                            scheduleItem,
+                            playoutItems,
+                            nextItemStart);
+                    }
+
+                    if (scheduleItem.FallbackFiller != null)
+                    {
+                        (nextState, playoutItems) = AddFallbackFiller(
+                            nextState,
+                            collectionEnumerators,
+                            scheduleItem,
+                            playoutItems,
+                            nextItemStart);
+                    }
+
+                    nextState = nextState with { CurrentTime = nextItemStart };
+                    break;
+                case TailMode.Offline:
+                    if (scheduleItem.FallbackFiller != null)
+                    {
+                        (nextState, playoutItems) = AddFallbackFiller(
+                            nextState,
+                            collectionEnumerators,
+                            scheduleItem,
+                            playoutItems,
+                            nextItemStart);
+                    }
+
+                    nextState = nextState with { CurrentTime = nextItemStart };
+                    break;
+            }
+        }
+
+        // clear guide finish on all but the last item
+        var all = playoutItems.Filter(pi => pi.FillerKind == FillerKind.None).ToList();
+        PlayoutItem last = all.OrderBy(pi => pi.FinishOffset).LastOrDefault();
+        foreach (PlayoutItem item in all.Filter(pi => pi != last))
+        {
+            item.GuideFinish = null;
+        }
+
+        nextState = nextState with { NextGuideGroup = nextState.IncrementGuideGroup };
+            
+        return Tuple(nextState, playoutItems);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerFlood.cs b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerFlood.cs
index c2d1e3694..9f900b2ca 100644
--- a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerFlood.cs
+++ b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerFlood.cs
@@ -1,144 +1,139 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class PlayoutModeSchedulerFlood : PlayoutModeSchedulerBase<ProgramScheduleItemFlood>
 {
-    public class PlayoutModeSchedulerFlood : PlayoutModeSchedulerBase<ProgramScheduleItemFlood>
+    public PlayoutModeSchedulerFlood(ILogger logger)
+        : base(logger)
     {
-        public PlayoutModeSchedulerFlood(ILogger logger)
-            : base(logger)
-        {
-        }
-
-        public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
-            ProgramScheduleItemFlood scheduleItem,
-            ProgramScheduleItem nextScheduleItem,
-            DateTimeOffset hardStop)
-        {
-            var playoutItems = new List<PlayoutItem>();
-
-            PlayoutBuilderState nextState = playoutBuilderState;
-            var willFinishInTime = true;
-
-            IMediaCollectionEnumerator contentEnumerator =
-                collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
-
-            ProgramScheduleItem peekScheduleItem = nextScheduleItem;
-
-            while (contentEnumerator.Current.IsSome && nextState.CurrentTime < hardStop && willFinishInTime)
-            {
-                MediaItem mediaItem = contentEnumerator.Current.ValueUnsafe();
-
-                // find when we should start this item, based on the current time
-                DateTimeOffset itemStartTime = GetStartTimeAfter(nextState, scheduleItem);
-                TimeSpan itemDuration = DurationForMediaItem(mediaItem);
-                List<MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
-                
-                var playoutItem = new PlayoutItem
-                {
-                    MediaItemId = mediaItem.Id,
-                    Start = itemStartTime.UtcDateTime,
-                    Finish = itemStartTime.UtcDateTime + itemDuration,
-                    InPoint = TimeSpan.Zero,
-                    OutPoint = itemDuration,
-                    GuideGroup = nextState.NextGuideGroup,
-                    FillerKind = scheduleItem.GuideMode == GuideMode.Filler
-                        ? FillerKind.Tail
-                        : FillerKind.None
-                };
-                
-                DateTimeOffset peekScheduleItemStart =
-                    peekScheduleItem.StartType == StartType.Fixed
-                        ? GetStartTimeAfter(nextState with { InFlood = false }, peekScheduleItem)
-                        : DateTimeOffset.MaxValue;
-
-                DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
-                    collectionEnumerators,
-                    scheduleItem,
-                    itemStartTime,
-                    itemDuration,
-                    itemChapters);
-                
-                // if the next schedule item is supposed to start during this item,
-                // don't schedule this item and just move on
-                willFinishInTime = peekScheduleItemStart < itemStartTime ||
-                                   peekScheduleItemStart >= itemEndTimeWithFiller;
-
-                if (willFinishInTime)
-                {
-                    playoutItems.AddRange(
-                        AddFiller(nextState, collectionEnumerators, scheduleItem, playoutItem, itemChapters));
-                    LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
-
-                    DateTimeOffset actualEndTime = playoutItems.Max(p => p.FinishOffset);
-                    if (Math.Abs((itemEndTimeWithFiller - actualEndTime).TotalSeconds) > 1)
-                    {
-                        _logger.LogWarning(
-                            "Filler prediction failure: predicted {PredictedDuration} doesn't match actual {ActualDuration}",
-                            itemEndTimeWithFiller,
-                            actualEndTime);
-
-                        // _logger.LogWarning("Playout items: {@PlayoutItems}", playoutItems);
-                    }
-
-                    nextState = nextState with
-                    {
-                        CurrentTime = itemEndTimeWithFiller,
-                        InFlood = true,
-                        NextGuideGroup = nextState.IncrementGuideGroup
-                    };
-
-                    contentEnumerator.MoveNext();
-                }
-            }
-
-            _logger.LogDebug(
-                "Advancing to next schedule item after playout mode {PlayoutMode}",
-                "Flood");
-
-            nextState = nextState with
-            {
-                InFlood = nextState.CurrentTime >= hardStop,
-                NextGuideGroup = nextState.DecrementGuideGroup
-            };
-
-            nextState.ScheduleItemsEnumerator.MoveNext();
-
-            ProgramScheduleItem peekItem = nextScheduleItem;
-            DateTimeOffset peekItemStart = GetStartTimeAfter(nextState, peekItem);
-
-            if (scheduleItem.TailFiller != null)
-            {
-                (nextState, playoutItems) = AddTailFiller(
-                    nextState,
-                    collectionEnumerators,
-                    scheduleItem,
-                    playoutItems,
-                    peekItemStart);
-            }
-
-            if (scheduleItem.FallbackFiller != null)
-            {
-                (nextState, playoutItems) = AddFallbackFiller(
-                    nextState,
-                    collectionEnumerators,
-                    scheduleItem,
-                    playoutItems,
-                    peekItemStart);
-            }
-
-            nextState = nextState with { NextGuideGroup = nextState.IncrementGuideGroup };
-
-            return Tuple(nextState, playoutItems);
-        }
     }
-}
+
+    public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+        ProgramScheduleItemFlood scheduleItem,
+        ProgramScheduleItem nextScheduleItem,
+        DateTimeOffset hardStop)
+    {
+        var playoutItems = new List<PlayoutItem>();
+
+        PlayoutBuilderState nextState = playoutBuilderState;
+        var willFinishInTime = true;
+
+        IMediaCollectionEnumerator contentEnumerator =
+            collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
+
+        ProgramScheduleItem peekScheduleItem = nextScheduleItem;
+
+        while (contentEnumerator.Current.IsSome && nextState.CurrentTime < hardStop && willFinishInTime)
+        {
+            MediaItem mediaItem = contentEnumerator.Current.ValueUnsafe();
+
+            // find when we should start this item, based on the current time
+            DateTimeOffset itemStartTime = GetStartTimeAfter(nextState, scheduleItem);
+            TimeSpan itemDuration = DurationForMediaItem(mediaItem);
+            List<MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
+                
+            var playoutItem = new PlayoutItem
+            {
+                MediaItemId = mediaItem.Id,
+                Start = itemStartTime.UtcDateTime,
+                Finish = itemStartTime.UtcDateTime + itemDuration,
+                InPoint = TimeSpan.Zero,
+                OutPoint = itemDuration,
+                GuideGroup = nextState.NextGuideGroup,
+                FillerKind = scheduleItem.GuideMode == GuideMode.Filler
+                    ? FillerKind.Tail
+                    : FillerKind.None
+            };
+                
+            DateTimeOffset peekScheduleItemStart =
+                peekScheduleItem.StartType == StartType.Fixed
+                    ? GetStartTimeAfter(nextState with { InFlood = false }, peekScheduleItem)
+                    : DateTimeOffset.MaxValue;
+
+            DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
+                collectionEnumerators,
+                scheduleItem,
+                itemStartTime,
+                itemDuration,
+                itemChapters);
+                
+            // if the next schedule item is supposed to start during this item,
+            // don't schedule this item and just move on
+            willFinishInTime = peekScheduleItemStart < itemStartTime ||
+                               peekScheduleItemStart >= itemEndTimeWithFiller;
+
+            if (willFinishInTime)
+            {
+                playoutItems.AddRange(
+                    AddFiller(nextState, collectionEnumerators, scheduleItem, playoutItem, itemChapters));
+                LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
+
+                DateTimeOffset actualEndTime = playoutItems.Max(p => p.FinishOffset);
+                if (Math.Abs((itemEndTimeWithFiller - actualEndTime).TotalSeconds) > 1)
+                {
+                    _logger.LogWarning(
+                        "Filler prediction failure: predicted {PredictedDuration} doesn't match actual {ActualDuration}",
+                        itemEndTimeWithFiller,
+                        actualEndTime);
+
+                    // _logger.LogWarning("Playout items: {@PlayoutItems}", playoutItems);
+                }
+
+                nextState = nextState with
+                {
+                    CurrentTime = itemEndTimeWithFiller,
+                    InFlood = true,
+                    NextGuideGroup = nextState.IncrementGuideGroup
+                };
+
+                contentEnumerator.MoveNext();
+            }
+        }
+
+        _logger.LogDebug(
+            "Advancing to next schedule item after playout mode {PlayoutMode}",
+            "Flood");
+
+        nextState = nextState with
+        {
+            InFlood = nextState.CurrentTime >= hardStop,
+            NextGuideGroup = nextState.DecrementGuideGroup
+        };
+
+        nextState.ScheduleItemsEnumerator.MoveNext();
+
+        ProgramScheduleItem peekItem = nextScheduleItem;
+        DateTimeOffset peekItemStart = GetStartTimeAfter(nextState, peekItem);
+
+        if (scheduleItem.TailFiller != null)
+        {
+            (nextState, playoutItems) = AddTailFiller(
+                nextState,
+                collectionEnumerators,
+                scheduleItem,
+                playoutItems,
+                peekItemStart);
+        }
+
+        if (scheduleItem.FallbackFiller != null)
+        {
+            (nextState, playoutItems) = AddFallbackFiller(
+                nextState,
+                collectionEnumerators,
+                scheduleItem,
+                playoutItems,
+                peekItemStart);
+        }
+
+        nextState = nextState with { NextGuideGroup = nextState.IncrementGuideGroup };
+
+        return Tuple(nextState, playoutItems);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerMultiple.cs b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerMultiple.cs
index b53dc8ef8..22dbba60b 100644
--- a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerMultiple.cs
+++ b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerMultiple.cs
@@ -1,134 +1,129 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class PlayoutModeSchedulerMultiple : PlayoutModeSchedulerBase<ProgramScheduleItemMultiple>
 {
-    public class PlayoutModeSchedulerMultiple : PlayoutModeSchedulerBase<ProgramScheduleItemMultiple>
-    {
-        private readonly Map<CollectionKey, List<MediaItem>> _collectionMediaItems;
+    private readonly Map<CollectionKey, List<MediaItem>> _collectionMediaItems;
 
-        public PlayoutModeSchedulerMultiple(Map<CollectionKey, List<MediaItem>> collectionMediaItems, ILogger logger)
-            : base(logger)
+    public PlayoutModeSchedulerMultiple(Map<CollectionKey, List<MediaItem>> collectionMediaItems, ILogger logger)
+        : base(logger)
+    {
+        _collectionMediaItems = collectionMediaItems;
+    }
+
+    public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+        ProgramScheduleItemMultiple scheduleItem,
+        ProgramScheduleItem nextScheduleItem,
+        DateTimeOffset hardStop)
+    {
+        var playoutItems = new List<PlayoutItem>();
+            
+        PlayoutBuilderState nextState = playoutBuilderState with
         {
-            _collectionMediaItems = collectionMediaItems;
+            MultipleRemaining = playoutBuilderState.MultipleRemaining.IfNone(scheduleItem.Count)
+        };
+
+        if (nextState.MultipleRemaining == 0)
+        {
+            nextState = nextState with
+            {
+                MultipleRemaining = _collectionMediaItems[CollectionKey.ForScheduleItem(scheduleItem)].Count
+            };
         }
 
-        public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
-            ProgramScheduleItemMultiple scheduleItem,
-            ProgramScheduleItem nextScheduleItem,
-            DateTimeOffset hardStop)
+        IMediaCollectionEnumerator contentEnumerator =
+            collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
+        while (contentEnumerator.Current.IsSome && nextState.MultipleRemaining > 0 &&
+               nextState.CurrentTime < hardStop)
         {
-            var playoutItems = new List<PlayoutItem>();
-            
-            PlayoutBuilderState nextState = playoutBuilderState with
+            MediaItem mediaItem = contentEnumerator.Current.ValueUnsafe();
+
+            // find when we should start this item, based on the current time
+            DateTimeOffset itemStartTime = GetStartTimeAfter(nextState, scheduleItem);
+
+            TimeSpan itemDuration = DurationForMediaItem(mediaItem);
+            List<MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
+
+            var playoutItem = new PlayoutItem
             {
-                MultipleRemaining = playoutBuilderState.MultipleRemaining.IfNone(scheduleItem.Count)
+                MediaItemId = mediaItem.Id,
+                Start = itemStartTime.UtcDateTime,
+                Finish = itemStartTime.UtcDateTime + itemDuration,
+                InPoint = TimeSpan.Zero,
+                OutPoint = itemDuration,
+                GuideGroup = nextState.NextGuideGroup,
+                FillerKind = scheduleItem.GuideMode == GuideMode.Filler
+                    ? FillerKind.Tail
+                    : FillerKind.None
             };
 
-            if (nextState.MultipleRemaining == 0)
-            {
-                nextState = nextState with
-                {
-                    MultipleRemaining = _collectionMediaItems[CollectionKey.ForScheduleItem(scheduleItem)].Count
-                };
-            }
+            // LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
+            DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
+                collectionEnumerators,
+                scheduleItem,
+                itemStartTime,
+                itemDuration,
+                itemChapters);
 
-            IMediaCollectionEnumerator contentEnumerator =
-                collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
-            while (contentEnumerator.Current.IsSome && nextState.MultipleRemaining > 0 &&
-                   nextState.CurrentTime < hardStop)
-            {
-                MediaItem mediaItem = contentEnumerator.Current.ValueUnsafe();
-
-                // find when we should start this item, based on the current time
-                DateTimeOffset itemStartTime = GetStartTimeAfter(nextState, scheduleItem);
-
-                TimeSpan itemDuration = DurationForMediaItem(mediaItem);
-                List<MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
-
-                var playoutItem = new PlayoutItem
-                {
-                    MediaItemId = mediaItem.Id,
-                    Start = itemStartTime.UtcDateTime,
-                    Finish = itemStartTime.UtcDateTime + itemDuration,
-                    InPoint = TimeSpan.Zero,
-                    OutPoint = itemDuration,
-                    GuideGroup = nextState.NextGuideGroup,
-                    FillerKind = scheduleItem.GuideMode == GuideMode.Filler
-                        ? FillerKind.Tail
-                        : FillerKind.None
-                };
-
-                // LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
-                DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
-                    collectionEnumerators,
-                    scheduleItem,
-                    itemStartTime,
-                    itemDuration,
-                    itemChapters);
-
-                playoutItems.AddRange(
-                    AddFiller(nextState, collectionEnumerators, scheduleItem, playoutItem, itemChapters));
+            playoutItems.AddRange(
+                AddFiller(nextState, collectionEnumerators, scheduleItem, playoutItem, itemChapters));
                 
-                nextState = nextState with
-                {
-                    CurrentTime = itemEndTimeWithFiller,
-                    MultipleRemaining = nextState.MultipleRemaining.Map(i => i - 1),
-                    NextGuideGroup = nextState.IncrementGuideGroup
-                };
-
-                contentEnumerator.MoveNext();
-            }
-
-            if (nextState.MultipleRemaining.IfNone(-1) == 0)
+            nextState = nextState with
             {
-                // _logger.LogDebug(
-                //     "Advancing to next schedule item after playout mode {PlayoutMode}",
-                //     "Multiple");
+                CurrentTime = itemEndTimeWithFiller,
+                MultipleRemaining = nextState.MultipleRemaining.Map(i => i - 1),
+                NextGuideGroup = nextState.IncrementGuideGroup
+            };
 
-                nextState = nextState with
-                {
-                    MultipleRemaining = None,
-                    NextGuideGroup = nextState.DecrementGuideGroup
-                };
-
-                nextState.ScheduleItemsEnumerator.MoveNext();
-            }
-            
-            DateTimeOffset nextItemStart = GetStartTimeAfter(nextState, nextScheduleItem);
-
-            if (scheduleItem.TailFiller != null)
-            {
-                (nextState, playoutItems) = AddTailFiller(
-                    nextState,
-                    collectionEnumerators,
-                    scheduleItem,
-                    playoutItems,
-                    nextItemStart);
-            }
-
-            if (scheduleItem.FallbackFiller != null)
-            {
-                (nextState, playoutItems) = AddFallbackFiller(
-                    nextState,
-                    collectionEnumerators,
-                    scheduleItem,
-                    playoutItems,
-                    nextItemStart);
-            }
-            
-            nextState = nextState with { NextGuideGroup = nextState.IncrementGuideGroup };
-
-            return Tuple(nextState, playoutItems);
+            contentEnumerator.MoveNext();
         }
+
+        if (nextState.MultipleRemaining.IfNone(-1) == 0)
+        {
+            // _logger.LogDebug(
+            //     "Advancing to next schedule item after playout mode {PlayoutMode}",
+            //     "Multiple");
+
+            nextState = nextState with
+            {
+                MultipleRemaining = None,
+                NextGuideGroup = nextState.DecrementGuideGroup
+            };
+
+            nextState.ScheduleItemsEnumerator.MoveNext();
+        }
+            
+        DateTimeOffset nextItemStart = GetStartTimeAfter(nextState, nextScheduleItem);
+
+        if (scheduleItem.TailFiller != null)
+        {
+            (nextState, playoutItems) = AddTailFiller(
+                nextState,
+                collectionEnumerators,
+                scheduleItem,
+                playoutItems,
+                nextItemStart);
+        }
+
+        if (scheduleItem.FallbackFiller != null)
+        {
+            (nextState, playoutItems) = AddFallbackFiller(
+                nextState,
+                collectionEnumerators,
+                scheduleItem,
+                playoutItems,
+                nextItemStart);
+        }
+            
+        nextState = nextState with { NextGuideGroup = nextState.IncrementGuideGroup };
+
+        return Tuple(nextState, playoutItems);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerOne.cs b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerOne.cs
index 2cec6a286..2c67e3b09 100644
--- a/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerOne.cs
+++ b/ErsatzTV.Core/Scheduling/PlayoutModeSchedulerOne.cs
@@ -1,108 +1,104 @@
-using System;
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Interfaces.Scheduling;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class PlayoutModeSchedulerOne : PlayoutModeSchedulerBase<ProgramScheduleItemOne>
 {
-    public class PlayoutModeSchedulerOne : PlayoutModeSchedulerBase<ProgramScheduleItemOne>
+    public PlayoutModeSchedulerOne(ILogger logger) : base(logger)
     {
-        public PlayoutModeSchedulerOne(ILogger logger) : base(logger)
-        {
-        }
-
-        public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
-            PlayoutBuilderState playoutBuilderState,
-            Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
-            ProgramScheduleItemOne scheduleItem,
-            ProgramScheduleItem nextScheduleItem,
-            DateTimeOffset hardStop)
-        {
-            IMediaCollectionEnumerator contentEnumerator =
-                collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
-            foreach (MediaItem mediaItem in contentEnumerator.Current)
-            {
-                // find when we should start this item, based on the current time
-                DateTimeOffset itemStartTime = GetStartTimeAfter(
-                    playoutBuilderState,
-                    scheduleItem);
-
-                TimeSpan itemDuration = DurationForMediaItem(mediaItem);
-                List<MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
-
-                var playoutItem = new PlayoutItem
-                {
-                    MediaItemId = mediaItem.Id,
-                    Start = itemStartTime.UtcDateTime,
-                    Finish = itemStartTime.UtcDateTime + itemDuration,
-                    InPoint = TimeSpan.Zero,
-                    OutPoint = itemDuration,
-                    GuideGroup = playoutBuilderState.NextGuideGroup,
-                    FillerKind = scheduleItem.GuideMode == GuideMode.Filler
-                        ? FillerKind.Tail
-                        : FillerKind.None
-                };
-
-                DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
-                    collectionEnumerators,
-                    scheduleItem,
-                    itemStartTime,
-                    itemDuration,
-                    itemChapters);
-
-                List<PlayoutItem> playoutItems = AddFiller(
-                    playoutBuilderState,
-                    collectionEnumerators,
-                    scheduleItem,
-                    playoutItem,
-                    itemChapters);
-
-                // only play one item from collection, so always advance to the next item
-                // _logger.LogDebug(
-                //     "Advancing to next schedule item after playout mode {PlayoutMode}",
-                //     "One");
-
-                PlayoutBuilderState nextState = playoutBuilderState with
-                {
-                    CurrentTime = itemEndTimeWithFiller
-                };
-
-                nextState.ScheduleItemsEnumerator.MoveNext();
-                contentEnumerator.MoveNext();
-
-                // LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
-
-                DateTimeOffset nextItemStart = GetStartTimeAfter(nextState, nextScheduleItem);
-
-                if (scheduleItem.TailFiller != null)
-                {
-                    (nextState, playoutItems) = AddTailFiller(
-                        nextState,
-                        collectionEnumerators,
-                        scheduleItem,
-                        playoutItems,
-                        nextItemStart);
-                }
-
-                if (scheduleItem.FallbackFiller != null)
-                {
-                    (nextState, playoutItems) = AddFallbackFiller(
-                        nextState,
-                        collectionEnumerators,
-                        scheduleItem,
-                        playoutItems,
-                        nextItemStart);
-                }
-
-                nextState = nextState with { NextGuideGroup = nextState.IncrementGuideGroup };
-
-                return Tuple(nextState, playoutItems);
-            }
-            
-            return Tuple(playoutBuilderState, new List<PlayoutItem>());
-        }
     }
-}
+
+    public override Tuple<PlayoutBuilderState, List<PlayoutItem>> Schedule(
+        PlayoutBuilderState playoutBuilderState,
+        Dictionary<CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
+        ProgramScheduleItemOne scheduleItem,
+        ProgramScheduleItem nextScheduleItem,
+        DateTimeOffset hardStop)
+    {
+        IMediaCollectionEnumerator contentEnumerator =
+            collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
+        foreach (MediaItem mediaItem in contentEnumerator.Current)
+        {
+            // find when we should start this item, based on the current time
+            DateTimeOffset itemStartTime = GetStartTimeAfter(
+                playoutBuilderState,
+                scheduleItem);
+
+            TimeSpan itemDuration = DurationForMediaItem(mediaItem);
+            List<MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
+
+            var playoutItem = new PlayoutItem
+            {
+                MediaItemId = mediaItem.Id,
+                Start = itemStartTime.UtcDateTime,
+                Finish = itemStartTime.UtcDateTime + itemDuration,
+                InPoint = TimeSpan.Zero,
+                OutPoint = itemDuration,
+                GuideGroup = playoutBuilderState.NextGuideGroup,
+                FillerKind = scheduleItem.GuideMode == GuideMode.Filler
+                    ? FillerKind.Tail
+                    : FillerKind.None
+            };
+
+            DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
+                collectionEnumerators,
+                scheduleItem,
+                itemStartTime,
+                itemDuration,
+                itemChapters);
+
+            List<PlayoutItem> playoutItems = AddFiller(
+                playoutBuilderState,
+                collectionEnumerators,
+                scheduleItem,
+                playoutItem,
+                itemChapters);
+
+            // only play one item from collection, so always advance to the next item
+            // _logger.LogDebug(
+            //     "Advancing to next schedule item after playout mode {PlayoutMode}",
+            //     "One");
+
+            PlayoutBuilderState nextState = playoutBuilderState with
+            {
+                CurrentTime = itemEndTimeWithFiller
+            };
+
+            nextState.ScheduleItemsEnumerator.MoveNext();
+            contentEnumerator.MoveNext();
+
+            // LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
+
+            DateTimeOffset nextItemStart = GetStartTimeAfter(nextState, nextScheduleItem);
+
+            if (scheduleItem.TailFiller != null)
+            {
+                (nextState, playoutItems) = AddTailFiller(
+                    nextState,
+                    collectionEnumerators,
+                    scheduleItem,
+                    playoutItems,
+                    nextItemStart);
+            }
+
+            if (scheduleItem.FallbackFiller != null)
+            {
+                (nextState, playoutItems) = AddFallbackFiller(
+                    nextState,
+                    collectionEnumerators,
+                    scheduleItem,
+                    playoutItems,
+                    nextItemStart);
+            }
+
+            nextState = nextState with { NextGuideGroup = nextState.IncrementGuideGroup };
+
+            return Tuple(nextState, playoutItems);
+        }
+            
+        return Tuple(playoutBuilderState, new List<PlayoutItem>());
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/RandomizedMediaCollectionEnumerator.cs b/ErsatzTV.Core/Scheduling/RandomizedMediaCollectionEnumerator.cs
index 788c17cd6..9f331d578 100644
--- a/ErsatzTV.Core/Scheduling/RandomizedMediaCollectionEnumerator.cs
+++ b/ErsatzTV.Core/Scheduling/RandomizedMediaCollectionEnumerator.cs
@@ -1,44 +1,38 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class RandomizedMediaCollectionEnumerator : IMediaCollectionEnumerator
 {
-    public class RandomizedMediaCollectionEnumerator : IMediaCollectionEnumerator
+    private readonly IList<MediaItem> _mediaItems;
+    private readonly Random _random;
+    private int _index;
+
+    public RandomizedMediaCollectionEnumerator(IList<MediaItem> mediaItems, CollectionEnumeratorState state)
     {
-        private readonly IList<MediaItem> _mediaItems;
-        private readonly Random _random;
-        private int _index;
+        _mediaItems = mediaItems;
+        _random = new Random(state.Seed);
 
-        public RandomizedMediaCollectionEnumerator(IList<MediaItem> mediaItems, CollectionEnumeratorState state)
+        State = new CollectionEnumeratorState { Seed = state.Seed };
+        // we want to move at least once so we start with a random item and not the first
+        // because _index defaults to 0
+        while (State.Index <= state.Index)
         {
-            _mediaItems = mediaItems;
-            _random = new Random(state.Seed);
-
-            State = new CollectionEnumeratorState { Seed = state.Seed };
-            // we want to move at least once so we start with a random item and not the first
-            // because _index defaults to 0
-            while (State.Index <= state.Index)
-            {
-                MoveNext();
-            }
+            MoveNext();
         }
-
-        public CollectionEnumeratorState State { get; }
-
-        public Option<MediaItem> Current => _mediaItems.Any() ? _mediaItems[_index] : None;
-
-        public void MoveNext()
-        {
-            _index = _random.Next() % _mediaItems.Count;
-            State.Index++;
-        }
-
-        public Option<MediaItem> Peek(int offset) =>
-            throw new NotSupportedException();
     }
-}
+
+    public CollectionEnumeratorState State { get; }
+
+    public Option<MediaItem> Current => _mediaItems.Any() ? _mediaItems[_index] : None;
+
+    public void MoveNext()
+    {
+        _index = _random.Next() % _mediaItems.Count;
+        State.Index++;
+    }
+
+    public Option<MediaItem> Peek(int offset) =>
+        throw new NotSupportedException();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/ShuffleInOrderCollectionEnumerator.cs b/ErsatzTV.Core/Scheduling/ShuffleInOrderCollectionEnumerator.cs
index 9c1fc2c53..91e669118 100644
--- a/ErsatzTV.Core/Scheduling/ShuffleInOrderCollectionEnumerator.cs
+++ b/ErsatzTV.Core/Scheduling/ShuffleInOrderCollectionEnumerator.cs
@@ -1,193 +1,186 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class ShuffleInOrderCollectionEnumerator : IMediaCollectionEnumerator
 {
-    public class ShuffleInOrderCollectionEnumerator : IMediaCollectionEnumerator
+    private readonly IList<CollectionWithItems> _collections;
+    private readonly int _mediaItemCount;
+    private Random _random;
+    private IList<MediaItem> _shuffled;
+
+    public ShuffleInOrderCollectionEnumerator(
+        IList<CollectionWithItems> collections,
+        CollectionEnumeratorState state)
     {
-        private readonly IList<CollectionWithItems> _collections;
-        private readonly int _mediaItemCount;
-        private Random _random;
-        private IList<MediaItem> _shuffled;
+        _collections = collections;
+        _mediaItemCount = collections.Sum(c => c.MediaItems.Count);
 
-        public ShuffleInOrderCollectionEnumerator(
-            IList<CollectionWithItems> collections,
-            CollectionEnumeratorState state)
+        if (state.Index >= _mediaItemCount)
         {
-            _collections = collections;
-            _mediaItemCount = collections.Sum(c => c.MediaItems.Count);
-
-            if (state.Index >= _mediaItemCount)
-            {
-                state.Index = 0;
-                state.Seed = new Random(state.Seed).Next();
-            }
+            state.Index = 0;
+            state.Seed = new Random(state.Seed).Next();
+        }
             
-            _random = new Random(state.Seed);
-            _shuffled = Shuffle(_collections, _random);
+        _random = new Random(state.Seed);
+        _shuffled = Shuffle(_collections, _random);
             
-            State = new CollectionEnumeratorState { Seed = state.Seed };
-            while (State.Index < state.Index)
-            {
-                MoveNext();
-            }
-        }
-
-        public CollectionEnumeratorState State { get; }
-        
-        public Option<MediaItem> Current => _shuffled.Any() ? _shuffled[State.Index % _mediaItemCount] : None;
-
-        public void MoveNext()
+        State = new CollectionEnumeratorState { Seed = state.Seed };
+        while (State.Index < state.Index)
         {
-            if ((State.Index + 1) % _shuffled.Count == 0)
-            {
-                Option<MediaItem> tail = Current;
-
-                State.Index = 0;
-                do
-                {
-                    State.Seed = _random.Next();
-                    _random = new Random(State.Seed);
-                    _shuffled = Shuffle(_collections, _random);
-                } while (_collections.Count > 1 && Current == tail);
-            }
-            else
-            {
-                State.Index++;
-            }
-
-            State.Index %= _shuffled.Count;
-        }
-
-        public Option<MediaItem> Peek(int offset) => throw new NotSupportedException();
-
-        private IList<MediaItem> Shuffle(IList<CollectionWithItems> collections, Random random)
-        {
-            // based on https://keyj.emphy.de/balanced-shuffle/
-            
-            var orderedCollections = collections
-                .Filter(c => c.ScheduleAsGroup)
-                .Map(c => new OrderedCollection { Index = 0, Items = OrderItems(c) })
-                .ToList();
-
-            if (collections.Any(c => !c.ScheduleAsGroup))
-            {
-                orderedCollections.Add(
-                    new OrderedCollection
-                    {
-                        Index = 0,
-                        Items = Shuffle(
-                            collections.Filter(c => !c.ScheduleAsGroup).SelectMany(c => c.MediaItems.Map(Some)),
-                            random)
-                    });
-            }
-
-            List<OrderedCollection> filled = Fill(orderedCollections, random);
-
-            var result = new List<MediaItem>();
-            for (var i = 0; i < filled[0].Items.Count; i++)
-            {
-                var batch = filled.Select(collection => collection.Items[i]).ToList();
-                foreach (Option<MediaItem> maybeItem in Shuffle(batch, random))
-                {
-                    result.AddRange(maybeItem);
-                }
-            }
-
-            return result;
-        }
-
-        private List<OrderedCollection> Fill(List<OrderedCollection> orderedCollections, Random random)
-        {
-            var result = new List<OrderedCollection>();
-            int maxLength = orderedCollections.Max(c => c.Items.Count);
-
-            foreach (OrderedCollection collection in orderedCollections)
-            {
-                var items = new Queue<Option<MediaItem>>(collection.Items);
-                var spaces = new Queue<Option<MediaItem>>(
-                    Range(0, maxLength - collection.Items.Count).Map(_ => Option<MediaItem>.None).ToList());
-
-                Queue<Option<MediaItem>> smaller = collection.Items.Count < maxLength - collection.Items.Count
-                    ? items
-                    : spaces;
-                Queue<Option<MediaItem>> larger = collection.Items.Count < maxLength - collection.Items.Count
-                    ? spaces
-                    : items;
-
-                var ordered = new List<Option<MediaItem>>();
-                
-                int k = smaller.Count;
-                while (k > 0)
-                {
-                    int n = maxLength - ordered.Count;
-                    
-                    // compute optimal length +/- 10%
-                    double optimalLength = n / (double)k + (random.NextDouble() - 0.5) / 5.0;
-                    int r = Math.Clamp((int)optimalLength, 1, maxLength - k + 1);
-                    ordered.Add(smaller.Dequeue());
-                    for (var i = 0; i < r - 1; i++)
-                    {
-                        ordered.Add(larger.Dequeue());
-                    }
-
-                    k--;
-                }
-
-                if (smaller.Any())
-                {
-                    ordered.AddRange(smaller);
-                }
-
-                if (larger.Any())
-                {
-                    ordered.AddRange(larger);
-                }
-
-                result.Add(new OrderedCollection { Index = 0, Items = ordered });
-            }
-
-            return result;
-        }
-
-        private static IList<Option<MediaItem>> OrderItems(CollectionWithItems collectionWithItems)
-        {
-            if (collectionWithItems.UseCustomOrder)
-            {
-                return collectionWithItems.MediaItems.Map(Some).ToList();
-            }
-
-            return collectionWithItems.MediaItems
-                .OrderBy(identity, new ChronologicalMediaComparer())
-                .Map(Some)
-                .ToList();
-        }
-        
-        private static IList<Option<MediaItem>> Shuffle(IEnumerable<Option<MediaItem>> list, Random random)
-        {
-            Option<MediaItem>[] copy = list.ToArray();
-
-            int n = copy.Length;
-            while (n > 1)
-            {
-                n--;
-                int k = random.Next(n + 1);
-                (copy[k], copy[n]) = (copy[n], copy[k]);
-            }
-
-            return copy;
-        }
-
-        private class OrderedCollection
-        {
-            public int Index { get; set; }
-            public IList<Option<MediaItem>> Items { get; set; }
+            MoveNext();
         }
     }
-}
+
+    public CollectionEnumeratorState State { get; }
+        
+    public Option<MediaItem> Current => _shuffled.Any() ? _shuffled[State.Index % _mediaItemCount] : None;
+
+    public void MoveNext()
+    {
+        if ((State.Index + 1) % _shuffled.Count == 0)
+        {
+            Option<MediaItem> tail = Current;
+
+            State.Index = 0;
+            do
+            {
+                State.Seed = _random.Next();
+                _random = new Random(State.Seed);
+                _shuffled = Shuffle(_collections, _random);
+            } while (_collections.Count > 1 && Current == tail);
+        }
+        else
+        {
+            State.Index++;
+        }
+
+        State.Index %= _shuffled.Count;
+    }
+
+    public Option<MediaItem> Peek(int offset) => throw new NotSupportedException();
+
+    private IList<MediaItem> Shuffle(IList<CollectionWithItems> collections, Random random)
+    {
+        // based on https://keyj.emphy.de/balanced-shuffle/
+            
+        var orderedCollections = collections
+            .Filter(c => c.ScheduleAsGroup)
+            .Map(c => new OrderedCollection { Index = 0, Items = OrderItems(c) })
+            .ToList();
+
+        if (collections.Any(c => !c.ScheduleAsGroup))
+        {
+            orderedCollections.Add(
+                new OrderedCollection
+                {
+                    Index = 0,
+                    Items = Shuffle(
+                        collections.Filter(c => !c.ScheduleAsGroup).SelectMany(c => c.MediaItems.Map(Some)),
+                        random)
+                });
+        }
+
+        List<OrderedCollection> filled = Fill(orderedCollections, random);
+
+        var result = new List<MediaItem>();
+        for (var i = 0; i < filled[0].Items.Count; i++)
+        {
+            var batch = filled.Select(collection => collection.Items[i]).ToList();
+            foreach (Option<MediaItem> maybeItem in Shuffle(batch, random))
+            {
+                result.AddRange(maybeItem);
+            }
+        }
+
+        return result;
+    }
+
+    private List<OrderedCollection> Fill(List<OrderedCollection> orderedCollections, Random random)
+    {
+        var result = new List<OrderedCollection>();
+        int maxLength = orderedCollections.Max(c => c.Items.Count);
+
+        foreach (OrderedCollection collection in orderedCollections)
+        {
+            var items = new Queue<Option<MediaItem>>(collection.Items);
+            var spaces = new Queue<Option<MediaItem>>(
+                Range(0, maxLength - collection.Items.Count).Map(_ => Option<MediaItem>.None).ToList());
+
+            Queue<Option<MediaItem>> smaller = collection.Items.Count < maxLength - collection.Items.Count
+                ? items
+                : spaces;
+            Queue<Option<MediaItem>> larger = collection.Items.Count < maxLength - collection.Items.Count
+                ? spaces
+                : items;
+
+            var ordered = new List<Option<MediaItem>>();
+                
+            int k = smaller.Count;
+            while (k > 0)
+            {
+                int n = maxLength - ordered.Count;
+                    
+                // compute optimal length +/- 10%
+                double optimalLength = n / (double)k + (random.NextDouble() - 0.5) / 5.0;
+                int r = Math.Clamp((int)optimalLength, 1, maxLength - k + 1);
+                ordered.Add(smaller.Dequeue());
+                for (var i = 0; i < r - 1; i++)
+                {
+                    ordered.Add(larger.Dequeue());
+                }
+
+                k--;
+            }
+
+            if (smaller.Any())
+            {
+                ordered.AddRange(smaller);
+            }
+
+            if (larger.Any())
+            {
+                ordered.AddRange(larger);
+            }
+
+            result.Add(new OrderedCollection { Index = 0, Items = ordered });
+        }
+
+        return result;
+    }
+
+    private static IList<Option<MediaItem>> OrderItems(CollectionWithItems collectionWithItems)
+    {
+        if (collectionWithItems.UseCustomOrder)
+        {
+            return collectionWithItems.MediaItems.Map(Some).ToList();
+        }
+
+        return collectionWithItems.MediaItems
+            .OrderBy(identity, new ChronologicalMediaComparer())
+            .Map(Some)
+            .ToList();
+    }
+        
+    private static IList<Option<MediaItem>> Shuffle(IEnumerable<Option<MediaItem>> list, Random random)
+    {
+        Option<MediaItem>[] copy = list.ToArray();
+
+        int n = copy.Length;
+        while (n > 1)
+        {
+            n--;
+            int k = random.Next(n + 1);
+            (copy[k], copy[n]) = (copy[n], copy[k]);
+        }
+
+        return copy;
+    }
+
+    private class OrderedCollection
+    {
+        public int Index { get; set; }
+        public IList<Option<MediaItem>> Items { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/ShuffledMediaCollectionEnumerator.cs b/ErsatzTV.Core/Scheduling/ShuffledMediaCollectionEnumerator.cs
index 36c313886..73261adba 100644
--- a/ErsatzTV.Core/Scheduling/ShuffledMediaCollectionEnumerator.cs
+++ b/ErsatzTV.Core/Scheduling/ShuffledMediaCollectionEnumerator.cs
@@ -1,110 +1,104 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Core.Scheduling
+namespace ErsatzTV.Core.Scheduling;
+
+public class ShuffledMediaCollectionEnumerator : IMediaCollectionEnumerator
 {
-    public class ShuffledMediaCollectionEnumerator : IMediaCollectionEnumerator
+    private readonly int _mediaItemCount;
+    private readonly IList<GroupedMediaItem> _mediaItems;
+    private CloneableRandom _random;
+    private IList<MediaItem> _shuffled;
+
+    public ShuffledMediaCollectionEnumerator(
+        IList<GroupedMediaItem> mediaItems,
+        CollectionEnumeratorState state)
     {
-        private readonly int _mediaItemCount;
-        private readonly IList<GroupedMediaItem> _mediaItems;
-        private CloneableRandom _random;
-        private IList<MediaItem> _shuffled;
+        _mediaItemCount = mediaItems.Sum(i => 1 + Optional(i.Additional).Flatten().Count());
+        _mediaItems = mediaItems;
 
-        public ShuffledMediaCollectionEnumerator(
-            IList<GroupedMediaItem> mediaItems,
-            CollectionEnumeratorState state)
+        if (state.Index >= _mediaItems.Count)
         {
-            _mediaItemCount = mediaItems.Sum(i => 1 + Optional(i.Additional).Flatten().Count());
-            _mediaItems = mediaItems;
-
-            if (state.Index >= _mediaItems.Count)
-            {
-                state.Index = 0;
-                state.Seed = new Random(state.Seed).Next();
-            }
-
-            _random = new CloneableRandom(state.Seed);
-            _shuffled = Shuffle(_mediaItems, _random);
-
-            State = new CollectionEnumeratorState { Seed = state.Seed };
-            while (State.Index < state.Index)
-            {
-                MoveNext();
-            }
+            state.Index = 0;
+            state.Seed = new Random(state.Seed).Next();
         }
 
-        public CollectionEnumeratorState State { get; }
+        _random = new CloneableRandom(state.Seed);
+        _shuffled = Shuffle(_mediaItems, _random);
 
-        public Option<MediaItem> Current => _shuffled.Any() ? _shuffled[State.Index % _mediaItemCount] : None;
-
-        public void MoveNext()
+        State = new CollectionEnumeratorState { Seed = state.Seed };
+        while (State.Index < state.Index)
         {
-            if ((State.Index + 1) % _mediaItemCount == 0)
-            {
-                Option<MediaItem> tail = Current;
-
-                State.Index = 0;
-                do
-                {
-                    State.Seed = _random.Next();
-                    _random = new CloneableRandom(State.Seed);
-                    _shuffled = Shuffle(_mediaItems, _random);
-                } while (_mediaItems.Count > 1 && Current == tail);
-            }
-            else
-            {
-                State.Index++;
-            }
-
-            State.Index %= _mediaItemCount;
-        }
-
-        public Option<MediaItem> Peek(int offset)
-        {
-            if (offset == 0)
-            {
-                return Current;
-            }
-
-            if ((State.Index + offset) % _mediaItemCount == 0)
-            {
-                IList<MediaItem> shuffled;
-                Option<MediaItem> tail = Current;
-
-                // clone the random
-                CloneableRandom randomCopy = _random.Clone();
-                
-                do
-                {
-                    int newSeed = randomCopy.Next();
-                    randomCopy = new CloneableRandom(newSeed);
-                    shuffled = Shuffle(_mediaItems, randomCopy);
-                } while (_mediaItems.Count > 1 && shuffled[0] == tail);
-
-                return shuffled.Any() ? shuffled[0] : None;
-            }
-
-            return _shuffled.Any() ? _shuffled[(State.Index + offset) % _mediaItemCount] : None;
-        }
-
-        private IList<MediaItem> Shuffle(IEnumerable<GroupedMediaItem> list, CloneableRandom random)
-        {
-            GroupedMediaItem[] copy = list.ToArray();
-
-            int n = copy.Length;
-            while (n > 1)
-            {
-                n--;
-                int k = random.Next(n + 1);
-                (copy[k], copy[n]) = (copy[n], copy[k]);
-            }
-
-            return GroupedMediaItem.FlattenGroups(copy, _mediaItemCount);
+            MoveNext();
         }
     }
-}
+
+    public CollectionEnumeratorState State { get; }
+
+    public Option<MediaItem> Current => _shuffled.Any() ? _shuffled[State.Index % _mediaItemCount] : None;
+
+    public void MoveNext()
+    {
+        if ((State.Index + 1) % _mediaItemCount == 0)
+        {
+            Option<MediaItem> tail = Current;
+
+            State.Index = 0;
+            do
+            {
+                State.Seed = _random.Next();
+                _random = new CloneableRandom(State.Seed);
+                _shuffled = Shuffle(_mediaItems, _random);
+            } while (_mediaItems.Count > 1 && Current == tail);
+        }
+        else
+        {
+            State.Index++;
+        }
+
+        State.Index %= _mediaItemCount;
+    }
+
+    public Option<MediaItem> Peek(int offset)
+    {
+        if (offset == 0)
+        {
+            return Current;
+        }
+
+        if ((State.Index + offset) % _mediaItemCount == 0)
+        {
+            IList<MediaItem> shuffled;
+            Option<MediaItem> tail = Current;
+
+            // clone the random
+            CloneableRandom randomCopy = _random.Clone();
+                
+            do
+            {
+                int newSeed = randomCopy.Next();
+                randomCopy = new CloneableRandom(newSeed);
+                shuffled = Shuffle(_mediaItems, randomCopy);
+            } while (_mediaItems.Count > 1 && shuffled[0] == tail);
+
+            return shuffled.Any() ? shuffled[0] : None;
+        }
+
+        return _shuffled.Any() ? _shuffled[(State.Index + offset) % _mediaItemCount] : None;
+    }
+
+    private IList<MediaItem> Shuffle(IEnumerable<GroupedMediaItem> list, CloneableRandom random)
+    {
+        GroupedMediaItem[] copy = list.ToArray();
+
+        int n = copy.Length;
+        while (n > 1)
+        {
+            n--;
+            int k = random.Next(n + 1);
+            (copy[k], copy[n]) = (copy[n], copy[k]);
+        }
+
+        return GroupedMediaItem.FlattenGroups(copy, _mediaItemCount);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Scheduling/ShuffledScheduleItemsEnumerator.cs b/ErsatzTV.Core/Scheduling/ShuffledScheduleItemsEnumerator.cs
index bb872ef58..d84be83a5 100644
--- a/ErsatzTV.Core/Scheduling/ShuffledScheduleItemsEnumerator.cs
+++ b/ErsatzTV.Core/Scheduling/ShuffledScheduleItemsEnumerator.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Scheduling;
 
 namespace ErsatzTV.Core.Scheduling;
diff --git a/ErsatzTV.Core/Search/SearchItem.cs b/ErsatzTV.Core/Search/SearchItem.cs
index a4ce8c531..11e497a99 100644
--- a/ErsatzTV.Core/Search/SearchItem.cs
+++ b/ErsatzTV.Core/Search/SearchItem.cs
@@ -1,4 +1,3 @@
-namespace ErsatzTV.Core.Search
-{
-    public record SearchItem(string Type, int Id);
-}
+namespace ErsatzTV.Core.Search;
+
+public record SearchItem(string Type, int Id);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Search/SearchPageMap.cs b/ErsatzTV.Core/Search/SearchPageMap.cs
index 51b60bc0c..5734a301b 100644
--- a/ErsatzTV.Core/Search/SearchPageMap.cs
+++ b/ErsatzTV.Core/Search/SearchPageMap.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Core.Search
-{
-    public record SearchPageMap(Dictionary<char, int> PageMap);
-}
+public record SearchPageMap(Dictionary<char, int> PageMap);
\ No newline at end of file
diff --git a/ErsatzTV.Core/Search/SearchResult.cs b/ErsatzTV.Core/Search/SearchResult.cs
index fceca199f..569c76c9c 100644
--- a/ErsatzTV.Core/Search/SearchResult.cs
+++ b/ErsatzTV.Core/Search/SearchResult.cs
@@ -1,10 +1,6 @@
-using System.Collections.Generic;
-using LanguageExt;
+namespace ErsatzTV.Core.Search;
 
-namespace ErsatzTV.Core.Search
+public record SearchResult(List<SearchItem> Items, int TotalCount)
 {
-    public record SearchResult(List<SearchItem> Items, int TotalCount)
-    {
-        public Option<SearchPageMap> PageMap { get; set; }
-    }
-}
+    public Option<SearchPageMap> PageMap { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Settings.cs b/ErsatzTV.Core/Settings.cs
index 99918099a..5108fa3dd 100644
--- a/ErsatzTV.Core/Settings.cs
+++ b/ErsatzTV.Core/Settings.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Core
+namespace ErsatzTV.Core;
+
+public static class Settings
 {
-    public static class Settings
-    {
-        public static int ListenPort { get; set; }
-    }
-}
+    public static int ListenPort { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/SystemTime.cs b/ErsatzTV.Core/SystemTime.cs
index 02c15330a..b947398c1 100644
--- a/ErsatzTV.Core/SystemTime.cs
+++ b/ErsatzTV.Core/SystemTime.cs
@@ -1,10 +1,7 @@
-using System;
+namespace ErsatzTV.Core;
 
-namespace ErsatzTV.Core
+public static class SystemTime
 {
-    public static class SystemTime
-    {
-        public static DateTime MinValueUtc = new(0, DateTimeKind.Utc);
-        public static DateTime MaxValueUtc = new(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
-    }
-}
+    public static DateTime MinValueUtc = new(0, DateTimeKind.Utc);
+    public static DateTime MaxValueUtc = new(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Trakt/TraktConfiguration.cs b/ErsatzTV.Core/Trakt/TraktConfiguration.cs
index cafae7f10..85011fcae 100644
--- a/ErsatzTV.Core/Trakt/TraktConfiguration.cs
+++ b/ErsatzTV.Core/Trakt/TraktConfiguration.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Core.Trakt
+namespace ErsatzTV.Core.Trakt;
+
+public class TraktConfiguration
 {
-    public class TraktConfiguration
-    {
-        public string ClientId { get; set; }
-    }
-}
+    public string ClientId { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Core/Trakt/TraktListItemWithGuids.cs b/ErsatzTV.Core/Trakt/TraktListItemWithGuids.cs
index 9c5652aa9..cee264192 100644
--- a/ErsatzTV.Core/Trakt/TraktListItemWithGuids.cs
+++ b/ErsatzTV.Core/Trakt/TraktListItemWithGuids.cs
@@ -1,16 +1,14 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Core.Trakt
-{
-    public record TraktListItemWithGuids(
-        int TraktId,
-        int Rank,
-        string DisplayTitle,
-        string Title,
-        int? Year,
-        int Season,
-        int Episode,
-        TraktListItemKind Kind,
-        List<string> Guids);
-}
+namespace ErsatzTV.Core.Trakt;
+
+public record TraktListItemWithGuids(
+    int TraktId,
+    int Rank,
+    string DisplayTitle,
+    string Title,
+    int? Year,
+    int Season,
+    int Episode,
+    TraktListItemKind Kind,
+    List<string> Guids);
\ No newline at end of file
diff --git a/ErsatzTV.FFmpeg.Tests/PipelineBuilderTests.cs b/ErsatzTV.FFmpeg.Tests/PipelineBuilderTests.cs
index 716537fe3..1e74ee749 100644
--- a/ErsatzTV.FFmpeg.Tests/PipelineBuilderTests.cs
+++ b/ErsatzTV.FFmpeg.Tests/PipelineBuilderTests.cs
@@ -4,11 +4,11 @@ using ErsatzTV.FFmpeg.Encoder;
 using ErsatzTV.FFmpeg.Format;
 using ErsatzTV.FFmpeg.OutputFormat;
 using ErsatzTV.FFmpeg.State;
-using NUnit.Framework;
 using FluentAssertions;
 using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Moq;
+using NUnit.Framework;
 using static LanguageExt.Prelude;
 
 namespace ErsatzTV.FFmpeg.Tests;
diff --git a/ErsatzTV.FFmpeg/CommandGenerator.cs b/ErsatzTV.FFmpeg/CommandGenerator.cs
index ce524bfdd..0e4369233 100644
--- a/ErsatzTV.FFmpeg/CommandGenerator.cs
+++ b/ErsatzTV.FFmpeg/CommandGenerator.cs
@@ -1,6 +1,5 @@
 using ErsatzTV.FFmpeg.Environment;
 using ErsatzTV.FFmpeg.Option;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg;
 
diff --git a/ErsatzTV.FFmpeg/Decoder/AvailableDecoders.cs b/ErsatzTV.FFmpeg/Decoder/AvailableDecoders.cs
index d6aa397bf..000b920b0 100644
--- a/ErsatzTV.FFmpeg/Decoder/AvailableDecoders.cs
+++ b/ErsatzTV.FFmpeg/Decoder/AvailableDecoders.cs
@@ -1,7 +1,6 @@
 using ErsatzTV.FFmpeg.Decoder.Cuvid;
 using ErsatzTV.FFmpeg.Decoder.Qsv;
 using ErsatzTV.FFmpeg.Format;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.FFmpeg.Decoder;
diff --git a/ErsatzTV.FFmpeg/Encoder/AvailableEncoders.cs b/ErsatzTV.FFmpeg/Encoder/AvailableEncoders.cs
index 65e857994..2d1403432 100644
--- a/ErsatzTV.FFmpeg/Encoder/AvailableEncoders.cs
+++ b/ErsatzTV.FFmpeg/Encoder/AvailableEncoders.cs
@@ -5,7 +5,6 @@ using ErsatzTV.FFmpeg.Encoder.VideoToolbox;
 using ErsatzTV.FFmpeg.Format;
 using ErsatzTV.FFmpeg.State;
 using Microsoft.Extensions.Logging;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.Encoder;
 
diff --git a/ErsatzTV.FFmpeg/Encoder/Nvenc/EncoderH264Nvenc.cs b/ErsatzTV.FFmpeg/Encoder/Nvenc/EncoderH264Nvenc.cs
index be9d06dcd..f437145d2 100644
--- a/ErsatzTV.FFmpeg/Encoder/Nvenc/EncoderH264Nvenc.cs
+++ b/ErsatzTV.FFmpeg/Encoder/Nvenc/EncoderH264Nvenc.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Format;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.Encoder.Nvenc;
 
diff --git a/ErsatzTV.FFmpeg/Encoder/Nvenc/EncoderHevcNvenc.cs b/ErsatzTV.FFmpeg/Encoder/Nvenc/EncoderHevcNvenc.cs
index cfc736c66..66549579b 100644
--- a/ErsatzTV.FFmpeg/Encoder/Nvenc/EncoderHevcNvenc.cs
+++ b/ErsatzTV.FFmpeg/Encoder/Nvenc/EncoderHevcNvenc.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Format;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.Encoder.Nvenc;
 
diff --git a/ErsatzTV.FFmpeg/Encoder/Qsv/EncoderHevcQsv.cs b/ErsatzTV.FFmpeg/Encoder/Qsv/EncoderHevcQsv.cs
index 623423367..608dbc9b3 100644
--- a/ErsatzTV.FFmpeg/Encoder/Qsv/EncoderHevcQsv.cs
+++ b/ErsatzTV.FFmpeg/Encoder/Qsv/EncoderHevcQsv.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Format;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.Encoder.Qsv;
 
diff --git a/ErsatzTV.FFmpeg/Encoder/Vaapi/EncoderH264Vaapi.cs b/ErsatzTV.FFmpeg/Encoder/Vaapi/EncoderH264Vaapi.cs
index 1b5859c8d..bfb449039 100644
--- a/ErsatzTV.FFmpeg/Encoder/Vaapi/EncoderH264Vaapi.cs
+++ b/ErsatzTV.FFmpeg/Encoder/Vaapi/EncoderH264Vaapi.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Format;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.Encoder.Vaapi;
 
diff --git a/ErsatzTV.FFmpeg/Encoder/Vaapi/EncoderHevcVaapi.cs b/ErsatzTV.FFmpeg/Encoder/Vaapi/EncoderHevcVaapi.cs
index c980acdf2..d77728747 100644
--- a/ErsatzTV.FFmpeg/Encoder/Vaapi/EncoderHevcVaapi.cs
+++ b/ErsatzTV.FFmpeg/Encoder/Vaapi/EncoderHevcVaapi.cs
@@ -1,7 +1,6 @@
 using ErsatzTV.FFmpeg.Format;
 
 namespace ErsatzTV.FFmpeg.Encoder.Vaapi;
-using LanguageExt;
 
 public class EncoderHevcVaapi : EncoderBase
 {
diff --git a/ErsatzTV.FFmpeg/Environment/FFReportVariable.cs b/ErsatzTV.FFmpeg/Environment/FFReportVariable.cs
index a77bfefa0..78732490b 100644
--- a/ErsatzTV.FFmpeg/Environment/FFReportVariable.cs
+++ b/ErsatzTV.FFmpeg/Environment/FFReportVariable.cs
@@ -1,5 +1,4 @@
 using System.Runtime.InteropServices;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.Environment;
 
diff --git a/ErsatzTV.FFmpeg/FFmpegState.cs b/ErsatzTV.FFmpeg/FFmpegState.cs
index 41c07d856..e15f1b235 100644
--- a/ErsatzTV.FFmpeg/FFmpegState.cs
+++ b/ErsatzTV.FFmpeg/FFmpegState.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.OutputFormat;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg;
 
diff --git a/ErsatzTV.FFmpeg/Filter/AvailableDeinterlaceFilters.cs b/ErsatzTV.FFmpeg/Filter/AvailableDeinterlaceFilters.cs
index f5a07571e..edb20d090 100644
--- a/ErsatzTV.FFmpeg/Filter/AvailableDeinterlaceFilters.cs
+++ b/ErsatzTV.FFmpeg/Filter/AvailableDeinterlaceFilters.cs
@@ -1,6 +1,5 @@
 using ErsatzTV.FFmpeg.Filter.Cuda;
 using ErsatzTV.FFmpeg.Filter.Vaapi;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.Filter;
 
diff --git a/ErsatzTV.FFmpeg/Filter/ComplexFilter.cs b/ErsatzTV.FFmpeg/Filter/ComplexFilter.cs
index 1284b828d..30461f893 100644
--- a/ErsatzTV.FFmpeg/Filter/ComplexFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/ComplexFilter.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Environment;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.Filter;
 
diff --git a/ErsatzTV.FFmpeg/Filter/OverlayFilter.cs b/ErsatzTV.FFmpeg/Filter/OverlayFilter.cs
index eef2220f4..449f070ed 100644
--- a/ErsatzTV.FFmpeg/Filter/OverlayFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/OverlayFilter.cs
@@ -1,5 +1,4 @@
-using ErsatzTV.FFmpeg.Format;
-using ErsatzTV.FFmpeg.State;
+using ErsatzTV.FFmpeg.State;
 
 namespace ErsatzTV.FFmpeg.Filter;
 
diff --git a/ErsatzTV.FFmpeg/Filter/PixelFormatFilter.cs b/ErsatzTV.FFmpeg/Filter/PixelFormatFilter.cs
index b14f7fa55..3acf359b4 100644
--- a/ErsatzTV.FFmpeg/Filter/PixelFormatFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/PixelFormatFilter.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Format;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.FFmpeg.Filter;
 
diff --git a/ErsatzTV.FFmpeg/Filter/WatermarkPixelFormatFilter.cs b/ErsatzTV.FFmpeg/Filter/WatermarkPixelFormatFilter.cs
index f35160b30..85967e6e5 100644
--- a/ErsatzTV.FFmpeg/Filter/WatermarkPixelFormatFilter.cs
+++ b/ErsatzTV.FFmpeg/Filter/WatermarkPixelFormatFilter.cs
@@ -1,6 +1,4 @@
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.FFmpeg.Filter;
 
diff --git a/ErsatzTV.FFmpeg/Format/AvailablePixelFormats.cs b/ErsatzTV.FFmpeg/Format/AvailablePixelFormats.cs
index 7e40f656f..44b5bbc18 100644
--- a/ErsatzTV.FFmpeg/Format/AvailablePixelFormats.cs
+++ b/ErsatzTV.FFmpeg/Format/AvailablePixelFormats.cs
@@ -1,5 +1,4 @@
-using LanguageExt;
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.FFmpeg.Format;
 
diff --git a/ErsatzTV.FFmpeg/FrameState.cs b/ErsatzTV.FFmpeg/FrameState.cs
index bd36305b2..4dbf8fba0 100644
--- a/ErsatzTV.FFmpeg/FrameState.cs
+++ b/ErsatzTV.FFmpeg/FrameState.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Format;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg;
 
diff --git a/ErsatzTV.FFmpeg/GlobalUsings.cs b/ErsatzTV.FFmpeg/GlobalUsings.cs
new file mode 100644
index 000000000..9d0867420
--- /dev/null
+++ b/ErsatzTV.FFmpeg/GlobalUsings.cs
@@ -0,0 +1,4 @@
+global using LanguageExt;
+global using static LanguageExt.Prelude;
+global using Unit = LanguageExt.Unit;
+global using Array = System.Array;
\ No newline at end of file
diff --git a/ErsatzTV.FFmpeg/InputFile.cs b/ErsatzTV.FFmpeg/InputFile.cs
index 20a289315..dfec29c04 100644
--- a/ErsatzTV.FFmpeg/InputFile.cs
+++ b/ErsatzTV.FFmpeg/InputFile.cs
@@ -1,7 +1,6 @@
 using ErsatzTV.FFmpeg.Format;
 using ErsatzTV.FFmpeg.Option;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg;
 
diff --git a/ErsatzTV.FFmpeg/MediaStream.cs b/ErsatzTV.FFmpeg/MediaStream.cs
index 660b96174..dc97a71e5 100644
--- a/ErsatzTV.FFmpeg/MediaStream.cs
+++ b/ErsatzTV.FFmpeg/MediaStream.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Format;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg;
 
diff --git a/ErsatzTV.FFmpeg/Option/HardwareAcceleration/AvailableHardwareAccelerationOptions.cs b/ErsatzTV.FFmpeg/Option/HardwareAcceleration/AvailableHardwareAccelerationOptions.cs
index e2bc5276c..9d2bbdcb2 100644
--- a/ErsatzTV.FFmpeg/Option/HardwareAcceleration/AvailableHardwareAccelerationOptions.cs
+++ b/ErsatzTV.FFmpeg/Option/HardwareAcceleration/AvailableHardwareAccelerationOptions.cs
@@ -1,5 +1,4 @@
-using LanguageExt;
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 
 namespace ErsatzTV.FFmpeg.Option.HardwareAcceleration;
 
diff --git a/ErsatzTV.FFmpeg/Option/PixelFormatOutputOption.cs b/ErsatzTV.FFmpeg/Option/PixelFormatOutputOption.cs
index 4b60fc05a..c8707b18e 100644
--- a/ErsatzTV.FFmpeg/Option/PixelFormatOutputOption.cs
+++ b/ErsatzTV.FFmpeg/Option/PixelFormatOutputOption.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Format;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.FFmpeg.Option;
 
diff --git a/ErsatzTV.FFmpeg/OutputFormat/OutputFormatHls.cs b/ErsatzTV.FFmpeg/OutputFormat/OutputFormatHls.cs
index 54042dfe0..12c326354 100644
--- a/ErsatzTV.FFmpeg/OutputFormat/OutputFormatHls.cs
+++ b/ErsatzTV.FFmpeg/OutputFormat/OutputFormatHls.cs
@@ -1,5 +1,4 @@
 using ErsatzTV.FFmpeg.Environment;
-using LanguageExt;
 
 namespace ErsatzTV.FFmpeg.OutputFormat;
 
diff --git a/ErsatzTV.FFmpeg/PipelineBuilder.cs b/ErsatzTV.FFmpeg/PipelineBuilder.cs
index 0909ead35..75a7a171d 100644
--- a/ErsatzTV.FFmpeg/PipelineBuilder.cs
+++ b/ErsatzTV.FFmpeg/PipelineBuilder.cs
@@ -10,9 +10,7 @@ using ErsatzTV.FFmpeg.Option.Metadata;
 using ErsatzTV.FFmpeg.OutputFormat;
 using ErsatzTV.FFmpeg.Protocol;
 using ErsatzTV.FFmpeg.State;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
 namespace ErsatzTV.FFmpeg;
 
diff --git a/ErsatzTV.FFmpeg/State/AudioState.cs b/ErsatzTV.FFmpeg/State/AudioState.cs
index 648f4aa37..215f49128 100644
--- a/ErsatzTV.FFmpeg/State/AudioState.cs
+++ b/ErsatzTV.FFmpeg/State/AudioState.cs
@@ -1,6 +1,4 @@
-using LanguageExt;
-
-namespace ErsatzTV.FFmpeg.State;
+namespace ErsatzTV.FFmpeg.State;
 
 public record AudioState(
     Option<string> AudioFormat,
diff --git a/ErsatzTV.FFmpeg/State/WatermarkState.cs b/ErsatzTV.FFmpeg/State/WatermarkState.cs
index b95c5bf6d..e559468c7 100644
--- a/ErsatzTV.FFmpeg/State/WatermarkState.cs
+++ b/ErsatzTV.FFmpeg/State/WatermarkState.cs
@@ -1,6 +1,4 @@
-using LanguageExt;
-
-namespace ErsatzTV.FFmpeg.State;
+namespace ErsatzTV.FFmpeg.State;
 
 public record WatermarkState(
     Option<List<WatermarkFadePoint>> MaybeFadePoints,
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ChannelConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ChannelConfiguration.cs
index 96d230d91..0620e8366 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ChannelConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ChannelConfiguration.cs
@@ -2,41 +2,40 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ChannelConfiguration : IEntityTypeConfiguration<Channel>
 {
-    public class ChannelConfiguration : IEntityTypeConfiguration<Channel>
+    public void Configure(EntityTypeBuilder<Channel> builder)
     {
-        public void Configure(EntityTypeBuilder<Channel> builder)
-        {
-            builder.ToTable("Channel");
+        builder.ToTable("Channel");
 
-            builder.HasIndex(c => c.Number)
-                .IsUnique();
+        builder.HasIndex(c => c.Number)
+            .IsUnique();
 
-            builder.HasMany(c => c.Playouts) // TODO: is this correct, or should we have one to one?
-                .WithOne(p => p.Channel)
-                .HasForeignKey(p => p.ChannelId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(c => c.Playouts) // TODO: is this correct, or should we have one to one?
+            .WithOne(p => p.Channel)
+            .HasForeignKey(p => p.ChannelId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(c => c.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(c => c.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasOne(i => i.Watermark)
-                .WithMany()
-                .HasForeignKey(i => i.WatermarkId)
-                .OnDelete(DeleteBehavior.SetNull)
-                .IsRequired(false);
+        builder.HasOne(i => i.Watermark)
+            .WithMany()
+            .HasForeignKey(i => i.WatermarkId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.FallbackFiller)
-                .WithMany()
-                .HasForeignKey(i => i.FallbackFillerId)
-                .OnDelete(DeleteBehavior.SetNull)
-                .IsRequired(false);
+        builder.HasOne(i => i.FallbackFiller)
+            .WithMany()
+            .HasForeignKey(i => i.FallbackFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
 
-            builder.Property(c => c.Group)
-                .IsRequired()
-                .HasDefaultValue("ErsatzTV");
-        }
+        builder.Property(c => c.Group)
+            .IsRequired()
+            .HasDefaultValue("ErsatzTV");
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ChannelWatermarkConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ChannelWatermarkConfiguration.cs
index a6779ad66..52c0bfd92 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ChannelWatermarkConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ChannelWatermarkConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ChannelWatermarkConfiguration : IEntityTypeConfiguration<ChannelWatermark>
 {
-    public class ChannelWatermarkConfiguration : IEntityTypeConfiguration<ChannelWatermark>
-    {
-        public void Configure(EntityTypeBuilder<ChannelWatermark> builder) => builder.ToTable("ChannelWatermark");
-    }
-}
+    public void Configure(EntityTypeBuilder<ChannelWatermark> builder) => builder.ToTable("ChannelWatermark");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Collection/CollectionConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Collection/CollectionConfiguration.cs
index c389a3fc9..1b900458e 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Collection/CollectionConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Collection/CollectionConfiguration.cs
@@ -2,26 +2,25 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
-{
-    public class CollectionConfiguration : IEntityTypeConfiguration<Collection>
-    {
-        public void Configure(EntityTypeBuilder<Collection> builder)
-        {
-            builder.ToTable("Collection");
+namespace ErsatzTV.Infrastructure.Data.Configurations;
 
-            builder.HasMany(c => c.MediaItems)
-                .WithMany(m => m.Collections)
-                .UsingEntity<CollectionItem>(
-                    j => j.HasOne(ci => ci.MediaItem)
-                        .WithMany(mi => mi.CollectionItems)
-                        .HasForeignKey(ci => ci.MediaItemId)
-                        .OnDelete(DeleteBehavior.Cascade),
-                    j => j.HasOne(ci => ci.Collection)
-                        .WithMany(c => c.CollectionItems)
-                        .HasForeignKey(ci => ci.CollectionId)
-                        .OnDelete(DeleteBehavior.Cascade),
-                    j => j.HasKey(ci => new { ci.CollectionId, ci.MediaItemId }));
-        }
+public class CollectionConfiguration : IEntityTypeConfiguration<Collection>
+{
+    public void Configure(EntityTypeBuilder<Collection> builder)
+    {
+        builder.ToTable("Collection");
+
+        builder.HasMany(c => c.MediaItems)
+            .WithMany(m => m.Collections)
+            .UsingEntity<CollectionItem>(
+                j => j.HasOne(ci => ci.MediaItem)
+                    .WithMany(mi => mi.CollectionItems)
+                    .HasForeignKey(ci => ci.MediaItemId)
+                    .OnDelete(DeleteBehavior.Cascade),
+                j => j.HasOne(ci => ci.Collection)
+                    .WithMany(c => c.CollectionItems)
+                    .HasForeignKey(ci => ci.CollectionId)
+                    .OnDelete(DeleteBehavior.Cascade),
+                j => j.HasKey(ci => new { ci.CollectionId, ci.MediaItemId }));
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Collection/CollectionItemConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Collection/CollectionItemConfiguration.cs
index 5f0ca3af6..22f1f7605 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Collection/CollectionItemConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Collection/CollectionItemConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class CollectionItemConfiguration : IEntityTypeConfiguration<CollectionItem>
 {
-    public class CollectionItemConfiguration : IEntityTypeConfiguration<CollectionItem>
-    {
-        public void Configure(EntityTypeBuilder<CollectionItem> builder) => builder.ToTable("CollectionItem");
-    }
-}
+    public void Configure(EntityTypeBuilder<CollectionItem> builder) => builder.ToTable("CollectionItem");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Collection/MultiCollectionConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Collection/MultiCollectionConfiguration.cs
index d96aa062b..e5c8d032d 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Collection/MultiCollectionConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Collection/MultiCollectionConfiguration.cs
@@ -2,39 +2,38 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
-{
-    public class MultiCollectionConfiguration : IEntityTypeConfiguration<MultiCollection>
-    {
-        public void Configure(EntityTypeBuilder<MultiCollection> builder)
-        {
-            builder.ToTable("MultiCollection");
-            
-            builder.HasMany(m => m.Collections)
-                .WithMany(m => m.MultiCollections)
-                .UsingEntity<MultiCollectionItem>(
-                    j => j.HasOne(mci => mci.Collection)
-                        .WithMany(c => c.MultiCollectionItems)
-                        .HasForeignKey(mci => mci.CollectionId)
-                        .OnDelete(DeleteBehavior.Cascade),
-                    j => j.HasOne(mci => mci.MultiCollection)
-                        .WithMany(mc => mc.MultiCollectionItems)
-                        .HasForeignKey(mci => mci.MultiCollectionId)
-                        .OnDelete(DeleteBehavior.Cascade),
-                    j => j.HasKey(mci => new { mci.MultiCollectionId, mci.CollectionId }));
+namespace ErsatzTV.Infrastructure.Data.Configurations;
 
-            builder.HasMany(m => m.SmartCollections)
-                .WithMany(m => m.MultiCollections)
-                .UsingEntity<MultiCollectionSmartItem>(
-                    j => j.HasOne(mci => mci.SmartCollection)
-                        .WithMany(c => c.MultiCollectionSmartItems)
-                        .HasForeignKey(mci => mci.SmartCollectionId)
-                        .OnDelete(DeleteBehavior.Cascade),
-                    j => j.HasOne(mci => mci.MultiCollection)
-                        .WithMany(mc => mc.MultiCollectionSmartItems)
-                        .HasForeignKey(mci => mci.MultiCollectionId)
-                        .OnDelete(DeleteBehavior.Cascade),
-                    j => j.HasKey(mci => new { mci.MultiCollectionId, mci.SmartCollectionId }));
-        }
+public class MultiCollectionConfiguration : IEntityTypeConfiguration<MultiCollection>
+{
+    public void Configure(EntityTypeBuilder<MultiCollection> builder)
+    {
+        builder.ToTable("MultiCollection");
+            
+        builder.HasMany(m => m.Collections)
+            .WithMany(m => m.MultiCollections)
+            .UsingEntity<MultiCollectionItem>(
+                j => j.HasOne(mci => mci.Collection)
+                    .WithMany(c => c.MultiCollectionItems)
+                    .HasForeignKey(mci => mci.CollectionId)
+                    .OnDelete(DeleteBehavior.Cascade),
+                j => j.HasOne(mci => mci.MultiCollection)
+                    .WithMany(mc => mc.MultiCollectionItems)
+                    .HasForeignKey(mci => mci.MultiCollectionId)
+                    .OnDelete(DeleteBehavior.Cascade),
+                j => j.HasKey(mci => new { mci.MultiCollectionId, mci.CollectionId }));
+
+        builder.HasMany(m => m.SmartCollections)
+            .WithMany(m => m.MultiCollections)
+            .UsingEntity<MultiCollectionSmartItem>(
+                j => j.HasOne(mci => mci.SmartCollection)
+                    .WithMany(c => c.MultiCollectionSmartItems)
+                    .HasForeignKey(mci => mci.SmartCollectionId)
+                    .OnDelete(DeleteBehavior.Cascade),
+                j => j.HasOne(mci => mci.MultiCollection)
+                    .WithMany(mc => mc.MultiCollectionSmartItems)
+                    .HasForeignKey(mci => mci.MultiCollectionId)
+                    .OnDelete(DeleteBehavior.Cascade),
+                j => j.HasKey(mci => new { mci.MultiCollectionId, mci.SmartCollectionId }));
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Collection/MultiCollectionItemConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Collection/MultiCollectionItemConfiguration.cs
index b7c68d092..fd0437196 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Collection/MultiCollectionItemConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Collection/MultiCollectionItemConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MultiCollectionItemConfiguration : IEntityTypeConfiguration<MultiCollectionItem>
 {
-    public class MultiCollectionItemConfiguration : IEntityTypeConfiguration<MultiCollectionItem>
-    {
-        public void Configure(EntityTypeBuilder<MultiCollectionItem> builder) => builder.ToTable("MultiCollectionItem");
-    }
-}
+    public void Configure(EntityTypeBuilder<MultiCollectionItem> builder) => builder.ToTable("MultiCollectionItem");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Collection/SmartCollectionConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Collection/SmartCollectionConfiguration.cs
index 08e477e05..78b7dd60d 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Collection/SmartCollectionConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Collection/SmartCollectionConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class SmartCollectionConfiguration : IEntityTypeConfiguration<SmartCollection>
 {
-    public class SmartCollectionConfiguration : IEntityTypeConfiguration<SmartCollection>
-    {
-        public void Configure(EntityTypeBuilder<SmartCollection> builder) => builder.ToTable("SmartCollection");
-    }
-}
+    public void Configure(EntityTypeBuilder<SmartCollection> builder) => builder.ToTable("SmartCollection");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListConfiguration.cs
index 56c789321..354d6f768 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListConfiguration.cs
@@ -2,18 +2,17 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
-{
-    public class TraktListConfiguration : IEntityTypeConfiguration<TraktList>
-    {
-        public void Configure(EntityTypeBuilder<TraktList> builder)
-        {
-            builder.ToTable("TraktList");
+namespace ErsatzTV.Infrastructure.Data.Configurations;
 
-            builder.HasMany(l => l.Items)
-                .WithOne(i => i.TraktList)
-                .HasForeignKey(i => i.TraktListId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+public class TraktListConfiguration : IEntityTypeConfiguration<TraktList>
+{
+    public void Configure(EntityTypeBuilder<TraktList> builder)
+    {
+        builder.ToTable("TraktList");
+
+        builder.HasMany(l => l.Items)
+            .WithOne(i => i.TraktList)
+            .HasForeignKey(i => i.TraktListId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListItemConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListItemConfiguration.cs
index 228677128..dbc30b9a7 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListItemConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListItemConfiguration.cs
@@ -2,21 +2,20 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class TraktListItemConfiguration : IEntityTypeConfiguration<TraktListItem>
 {
-    public class TraktListItemConfiguration : IEntityTypeConfiguration<TraktListItem>
+    public void Configure(EntityTypeBuilder<TraktListItem> builder)
     {
-        public void Configure(EntityTypeBuilder<TraktListItem> builder)
-        {
-            builder.ToTable("TraktListItem");
+        builder.ToTable("TraktListItem");
 
-            builder.HasOne(i => i.MediaItem)
-                .WithMany(mi => mi.TraktListItems)
-                .OnDelete(DeleteBehavior.SetNull);
+        builder.HasOne(i => i.MediaItem)
+            .WithMany(mi => mi.TraktListItems)
+            .OnDelete(DeleteBehavior.SetNull);
 
-            builder.HasMany(i => i.Guids)
-                .WithOne(g => g.TraktListItem)
-                .HasForeignKey(g => g.TraktListItemId);
-        }
+        builder.HasMany(i => i.Guids)
+            .WithOne(g => g.TraktListItem)
+            .HasForeignKey(g => g.TraktListItemId);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListItemGuidConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListItemGuidConfiguration.cs
index cbccdd172..746704b19 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListItemGuidConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Collection/TraktListItemGuidConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class TraktListItemGuidConfiguration : IEntityTypeConfiguration<TraktListItemGuid>
 {
-    public class TraktListItemGuidConfiguration : IEntityTypeConfiguration<TraktListItemGuid>
-    {
-        public void Configure(EntityTypeBuilder<TraktListItemGuid> builder) => builder.ToTable("TraktListItemGuid");
-    }
-}
+    public void Configure(EntityTypeBuilder<TraktListItemGuid> builder) => builder.ToTable("TraktListItemGuid");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ConfigElementConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ConfigElementConfiguration.cs
index 0f1da93bb..9f7ea32cf 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ConfigElementConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ConfigElementConfiguration.cs
@@ -2,16 +2,15 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
-{
-    public class ConfigElementConfiguration : IEntityTypeConfiguration<ConfigElement>
-    {
-        public void Configure(EntityTypeBuilder<ConfigElement> builder)
-        {
-            builder.ToTable("ConfigElement");
+namespace ErsatzTV.Infrastructure.Data.Configurations;
 
-            builder.HasIndex(ce => ce.Key)
-                .IsUnique();
-        }
+public class ConfigElementConfiguration : IEntityTypeConfiguration<ConfigElement>
+{
+    public void Configure(EntityTypeBuilder<ConfigElement> builder)
+    {
+        builder.ToTable("ConfigElement");
+
+        builder.HasIndex(ce => ce.Key)
+            .IsUnique();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/FFmpegProfileConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/FFmpegProfileConfiguration.cs
index 567ce7d67..221766ffe 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/FFmpegProfileConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/FFmpegProfileConfiguration.cs
@@ -2,16 +2,15 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
-{
-    public class FFmpegProfileConfiguration : IEntityTypeConfiguration<FFmpegProfile>
-    {
-        public void Configure(EntityTypeBuilder<FFmpegProfile> builder)
-        {
-            builder.ToTable("FFmpegProfile");
+namespace ErsatzTV.Infrastructure.Data.Configurations;
 
-            builder.Property(p => p.NormalizeFramerate)
-                .HasDefaultValue(false);
-        }
+public class FFmpegProfileConfiguration : IEntityTypeConfiguration<FFmpegProfile>
+{
+    public void Configure(EntityTypeBuilder<FFmpegProfile> builder)
+    {
+        builder.ToTable("FFmpegProfile");
+
+        builder.Property(p => p.NormalizeFramerate)
+            .HasDefaultValue(false);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Filler/FillerPresetConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Filler/FillerPresetConfiguration.cs
index 2b19f42c4..be5e1bd80 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Filler/FillerPresetConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Filler/FillerPresetConfiguration.cs
@@ -2,37 +2,36 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations.Filler
+namespace ErsatzTV.Infrastructure.Data.Configurations.Filler;
+
+public class FillerPresetConfiguration : IEntityTypeConfiguration<FillerPreset>
 {
-    public class FillerPresetConfiguration : IEntityTypeConfiguration<FillerPreset>
+    public void Configure(EntityTypeBuilder<FillerPreset> builder)
     {
-        public void Configure(EntityTypeBuilder<FillerPreset> builder)
-        {
-            builder.ToTable("FillerPreset");
+        builder.ToTable("FillerPreset");
 
-            builder.HasOne(i => i.Collection)
-                .WithMany()
-                .HasForeignKey(i => i.CollectionId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.Collection)
+            .WithMany()
+            .HasForeignKey(i => i.CollectionId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.MediaItem)
-                .WithMany()
-                .HasForeignKey(i => i.MediaItemId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.MediaItem)
+            .WithMany()
+            .HasForeignKey(i => i.MediaItemId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.MultiCollection)
-                .WithMany()
-                .HasForeignKey(i => i.MultiCollectionId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.MultiCollection)
+            .WithMany()
+            .HasForeignKey(i => i.MultiCollectionId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.SmartCollection)
-                .WithMany()
-                .HasForeignKey(i => i.SmartCollectionId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
-        }
+        builder.HasOne(i => i.SmartCollection)
+            .WithMany()
+            .HasForeignKey(i => i.SmartCollectionId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/LanguageCodeConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/LanguageCodeConfiguration.cs
index d7c454b83..ac967082e 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/LanguageCodeConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/LanguageCodeConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class LanguageCodeConfiguration : IEntityTypeConfiguration<LanguageCode>
 {
-    public class LanguageCodeConfiguration : IEntityTypeConfiguration<LanguageCode>
-    {
-        public void Configure(EntityTypeBuilder<LanguageCode> builder) => builder.ToTable("LanguageCode");
-    }
-}
+    public void Configure(EntityTypeBuilder<LanguageCode> builder) => builder.ToTable("LanguageCode");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Library/EmbyLibraryConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Library/EmbyLibraryConfiguration.cs
index 64dfffa6e..7e19f894f 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Library/EmbyLibraryConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Library/EmbyLibraryConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EmbyLibraryConfiguration : IEntityTypeConfiguration<EmbyLibrary>
 {
-    public class EmbyLibraryConfiguration : IEntityTypeConfiguration<EmbyLibrary>
-    {
-        public void Configure(EntityTypeBuilder<EmbyLibrary> builder) =>
-            builder.ToTable("EmbyLibrary");
-    }
-}
+    public void Configure(EntityTypeBuilder<EmbyLibrary> builder) =>
+        builder.ToTable("EmbyLibrary");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Library/JellyfinLibraryConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Library/JellyfinLibraryConfiguration.cs
index 45074a186..5f60f3b3a 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Library/JellyfinLibraryConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Library/JellyfinLibraryConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class JellyfinLibraryConfiguration : IEntityTypeConfiguration<JellyfinLibrary>
 {
-    public class JellyfinLibraryConfiguration : IEntityTypeConfiguration<JellyfinLibrary>
-    {
-        public void Configure(EntityTypeBuilder<JellyfinLibrary> builder) =>
-            builder.ToTable("JellyfinLibrary");
-    }
-}
+    public void Configure(EntityTypeBuilder<JellyfinLibrary> builder) =>
+        builder.ToTable("JellyfinLibrary");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryConfiguration.cs
index 3cc2a3ab5..3f4966a80 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class LibraryConfiguration : IEntityTypeConfiguration<Library>
 {
-    public class LibraryConfiguration : IEntityTypeConfiguration<Library>
-    {
-        public void Configure(EntityTypeBuilder<Library> builder) =>
-            builder.ToTable("Library");
-    }
-}
+    public void Configure(EntityTypeBuilder<Library> builder) =>
+        builder.ToTable("Library");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryFolderConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryFolderConfiguration.cs
index 6604614eb..40322ef65 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryFolderConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryFolderConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class LibraryFolderConfiguration : IEntityTypeConfiguration<LibraryFolder>
 {
-    public class LibraryFolderConfiguration : IEntityTypeConfiguration<LibraryFolder>
-    {
-        public void Configure(EntityTypeBuilder<LibraryFolder> builder) => builder.ToTable("LibraryFolder");
-    }
-}
+    public void Configure(EntityTypeBuilder<LibraryFolder> builder) => builder.ToTable("LibraryFolder");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryPathConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryPathConfiguration.cs
index 720dbc71d..e682d6396 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryPathConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Library/LibraryPathConfiguration.cs
@@ -2,23 +2,22 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class LibraryPathConfiguration : IEntityTypeConfiguration<LibraryPath>
 {
-    public class LibraryPathConfiguration : IEntityTypeConfiguration<LibraryPath>
+    public void Configure(EntityTypeBuilder<LibraryPath> builder)
     {
-        public void Configure(EntityTypeBuilder<LibraryPath> builder)
-        {
-            builder.ToTable("LibraryPath");
+        builder.ToTable("LibraryPath");
 
-            builder.HasMany(p => p.MediaItems)
-                .WithOne(i => i.LibraryPath)
-                .HasForeignKey(i => i.LibraryPathId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(p => p.MediaItems)
+            .WithOne(i => i.LibraryPath)
+            .HasForeignKey(i => i.LibraryPathId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(p => p.LibraryFolders)
-                .WithOne(f => f.LibraryPath)
-                .HasForeignKey(f => f.LibraryPathId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(p => p.LibraryFolders)
+            .WithOne(f => f.LibraryPath)
+            .HasForeignKey(f => f.LibraryPathId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Library/LocalLibraryConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Library/LocalLibraryConfiguration.cs
index bf2edef97..f169c6aa6 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Library/LocalLibraryConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Library/LocalLibraryConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class LocalLibraryConfiguration : IEntityTypeConfiguration<LocalLibrary>
 {
-    public class LocalLibraryConfiguration : IEntityTypeConfiguration<LocalLibrary>
-    {
-        public void Configure(EntityTypeBuilder<LocalLibrary> builder) =>
-            builder.ToTable("LocalLibrary");
-    }
-}
+    public void Configure(EntityTypeBuilder<LocalLibrary> builder) =>
+        builder.ToTable("LocalLibrary");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Library/PlexLibraryConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Library/PlexLibraryConfiguration.cs
index 777887f7b..86e96551a 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Library/PlexLibraryConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Library/PlexLibraryConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexLibraryConfiguration : IEntityTypeConfiguration<PlexLibrary>
 {
-    public class PlexLibraryConfiguration : IEntityTypeConfiguration<PlexLibrary>
-    {
-        public void Configure(EntityTypeBuilder<PlexLibrary> builder) =>
-            builder.ToTable("PlexLibrary");
-    }
-}
+    public void Configure(EntityTypeBuilder<PlexLibrary> builder) =>
+        builder.ToTable("PlexLibrary");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ArtistConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ArtistConfiguration.cs
index 4425b0e2e..c52821e29 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ArtistConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ArtistConfiguration.cs
@@ -2,23 +2,22 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ArtistConfiguration : IEntityTypeConfiguration<Artist>
 {
-    public class ArtistConfiguration : IEntityTypeConfiguration<Artist>
+    public void Configure(EntityTypeBuilder<Artist> builder)
     {
-        public void Configure(EntityTypeBuilder<Artist> builder)
-        {
-            builder.ToTable("Artist");
+        builder.ToTable("Artist");
 
-            builder.HasMany(a => a.MusicVideos)
-                .WithOne(mv => mv.Artist)
-                .HasForeignKey(mv => mv.ArtistId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(a => a.MusicVideos)
+            .WithOne(mv => mv.Artist)
+            .HasForeignKey(mv => mv.ArtistId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(a => a.ArtistMetadata)
-                .WithOne(am => am.Artist)
-                .HasForeignKey(am => am.ArtistId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(a => a.ArtistMetadata)
+            .WithOne(am => am.Artist)
+            .HasForeignKey(am => am.ArtistId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyEpisodeConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyEpisodeConfiguration.cs
index af597b817..099b344d3 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyEpisodeConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyEpisodeConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EmbyEpisodeConfiguration : IEntityTypeConfiguration<EmbyEpisode>
 {
-    public class EmbyEpisodeConfiguration : IEntityTypeConfiguration<EmbyEpisode>
-    {
-        public void Configure(EntityTypeBuilder<EmbyEpisode> builder) => builder.ToTable("EmbyEpisode");
-    }
-}
+    public void Configure(EntityTypeBuilder<EmbyEpisode> builder) => builder.ToTable("EmbyEpisode");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyMovieConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyMovieConfiguration.cs
index 83f8f720f..952f365f1 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyMovieConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyMovieConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EmbyMovieConfiguration : IEntityTypeConfiguration<EmbyMovie>
 {
-    public class EmbyMovieConfiguration : IEntityTypeConfiguration<EmbyMovie>
-    {
-        public void Configure(EntityTypeBuilder<EmbyMovie> builder) => builder.ToTable("EmbyMovie");
-    }
-}
+    public void Configure(EntityTypeBuilder<EmbyMovie> builder) => builder.ToTable("EmbyMovie");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbySeasonConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbySeasonConfiguration.cs
index bf767b275..da9084bb7 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbySeasonConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbySeasonConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EmbySeasonConfiguration : IEntityTypeConfiguration<EmbySeason>
 {
-    public class EmbySeasonConfiguration : IEntityTypeConfiguration<EmbySeason>
-    {
-        public void Configure(EntityTypeBuilder<EmbySeason> builder) => builder.ToTable("EmbySeason");
-    }
-}
+    public void Configure(EntityTypeBuilder<EmbySeason> builder) => builder.ToTable("EmbySeason");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyShowConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyShowConfiguration.cs
index 07f0c467f..f225fac8b 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyShowConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EmbyShowConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EmbyShowConfiguration : IEntityTypeConfiguration<EmbyShow>
 {
-    public class EmbyShowConfiguration : IEntityTypeConfiguration<EmbyShow>
-    {
-        public void Configure(EntityTypeBuilder<EmbyShow> builder) => builder.ToTable("EmbyShow");
-    }
-}
+    public void Configure(EntityTypeBuilder<EmbyShow> builder) => builder.ToTable("EmbyShow");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EpisodeConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EpisodeConfiguration.cs
index b541896db..405270360 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EpisodeConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/EpisodeConfiguration.cs
@@ -2,22 +2,21 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EpisodeConfiguration : IEntityTypeConfiguration<Episode>
 {
-    public class EpisodeConfiguration : IEntityTypeConfiguration<Episode>
+    public void Configure(EntityTypeBuilder<Episode> builder)
     {
-        public void Configure(EntityTypeBuilder<Episode> builder)
-        {
-            builder.ToTable("Episode");
+        builder.ToTable("Episode");
 
-            builder.HasMany(e => e.EpisodeMetadata)
-                .WithOne(m => m.Episode)
-                .HasForeignKey(m => m.EpisodeId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(e => e.EpisodeMetadata)
+            .WithOne(m => m.Episode)
+            .HasForeignKey(m => m.EpisodeId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(e => e.MediaVersions)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(e => e.MediaVersions)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinEpisodeConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinEpisodeConfiguration.cs
index 632f2c8d1..d4025c635 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinEpisodeConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinEpisodeConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class JellyfinEpisodeConfiguration : IEntityTypeConfiguration<JellyfinEpisode>
 {
-    public class JellyfinEpisodeConfiguration : IEntityTypeConfiguration<JellyfinEpisode>
-    {
-        public void Configure(EntityTypeBuilder<JellyfinEpisode> builder) => builder.ToTable("JellyfinEpisode");
-    }
-}
+    public void Configure(EntityTypeBuilder<JellyfinEpisode> builder) => builder.ToTable("JellyfinEpisode");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinMovieConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinMovieConfiguration.cs
index 60d86d098..166f7a315 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinMovieConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinMovieConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class JellyfinMovieConfiguration : IEntityTypeConfiguration<JellyfinMovie>
 {
-    public class JellyfinMovieConfiguration : IEntityTypeConfiguration<JellyfinMovie>
-    {
-        public void Configure(EntityTypeBuilder<JellyfinMovie> builder) => builder.ToTable("JellyfinMovie");
-    }
-}
+    public void Configure(EntityTypeBuilder<JellyfinMovie> builder) => builder.ToTable("JellyfinMovie");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinSeasonConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinSeasonConfiguration.cs
index 285b7f1cb..fedd81f7a 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinSeasonConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinSeasonConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class JellyfinSeasonConfiguration : IEntityTypeConfiguration<JellyfinSeason>
 {
-    public class JellyfinSeasonConfiguration : IEntityTypeConfiguration<JellyfinSeason>
-    {
-        public void Configure(EntityTypeBuilder<JellyfinSeason> builder) => builder.ToTable("JellyfinSeason");
-    }
-}
+    public void Configure(EntityTypeBuilder<JellyfinSeason> builder) => builder.ToTable("JellyfinSeason");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinShowConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinShowConfiguration.cs
index 4bce71f7d..947cefe24 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinShowConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/JellyfinShowConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class JellyfinShowConfiguration : IEntityTypeConfiguration<JellyfinShow>
 {
-    public class JellyfinShowConfiguration : IEntityTypeConfiguration<JellyfinShow>
-    {
-        public void Configure(EntityTypeBuilder<JellyfinShow> builder) => builder.ToTable("JellyfinShow");
-    }
-}
+    public void Configure(EntityTypeBuilder<JellyfinShow> builder) => builder.ToTable("JellyfinShow");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaChapterConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaChapterConfiguration.cs
index eba94e87f..484ddf512 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaChapterConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaChapterConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MediaChapterConfiguration : IEntityTypeConfiguration<MediaChapter>
 {
-    public class MediaChapterConfiguration : IEntityTypeConfiguration<MediaChapter>
-    {
-        public void Configure(EntityTypeBuilder<MediaChapter> builder) => builder.ToTable("MediaChapter");
-    }
-}
+    public void Configure(EntityTypeBuilder<MediaChapter> builder) => builder.ToTable("MediaChapter");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaFileConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaFileConfiguration.cs
index 1b7e189b4..5bb78a919 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaFileConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaFileConfiguration.cs
@@ -2,16 +2,15 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
-{
-    public class MediaFileConfiguration : IEntityTypeConfiguration<MediaFile>
-    {
-        public void Configure(EntityTypeBuilder<MediaFile> builder)
-        {
-            builder.ToTable("MediaFile");
+namespace ErsatzTV.Infrastructure.Data.Configurations;
 
-            builder.HasIndex(f => f.Path)
-                .IsUnique();
-        }
+public class MediaFileConfiguration : IEntityTypeConfiguration<MediaFile>
+{
+    public void Configure(EntityTypeBuilder<MediaFile> builder)
+    {
+        builder.ToTable("MediaFile");
+
+        builder.HasIndex(f => f.Path)
+            .IsUnique();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaItemConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaItemConfiguration.cs
index d9a066240..e18fd5e56 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaItemConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaItemConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MediaItemConfiguration : IEntityTypeConfiguration<MediaItem>
 {
-    public class MediaItemConfiguration : IEntityTypeConfiguration<MediaItem>
-    {
-        public void Configure(EntityTypeBuilder<MediaItem> builder) => builder.ToTable("MediaItem");
-    }
-}
+    public void Configure(EntityTypeBuilder<MediaItem> builder) => builder.ToTable("MediaItem");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaStreamConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaStreamConfiguration.cs
index c4667c9da..a84afafd7 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaStreamConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaStreamConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MediaStreamConfiguration : IEntityTypeConfiguration<MediaStream>
 {
-    public class MediaStreamConfiguration : IEntityTypeConfiguration<MediaStream>
-    {
-        public void Configure(EntityTypeBuilder<MediaStream> builder) => builder.ToTable("MediaStream");
-    }
-}
+    public void Configure(EntityTypeBuilder<MediaStream> builder) => builder.ToTable("MediaStream");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaVersionConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaVersionConfiguration.cs
index c5861949f..1fb5baaf9 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaVersionConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MediaVersionConfiguration.cs
@@ -2,28 +2,27 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MediaVersionConfiguration : IEntityTypeConfiguration<MediaVersion>
 {
-    public class MediaVersionConfiguration : IEntityTypeConfiguration<MediaVersion>
+    public void Configure(EntityTypeBuilder<MediaVersion> builder)
     {
-        public void Configure(EntityTypeBuilder<MediaVersion> builder)
-        {
-            builder.ToTable("MediaVersion");
+        builder.ToTable("MediaVersion");
 
-            builder.HasMany(v => v.MediaFiles)
-                .WithOne(f => f.MediaVersion)
-                .HasForeignKey(f => f.MediaVersionId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(v => v.MediaFiles)
+            .WithOne(f => f.MediaVersion)
+            .HasForeignKey(f => f.MediaVersionId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(v => v.Streams)
-                .WithOne(s => s.MediaVersion)
-                .HasForeignKey(s => s.MediaVersionId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(v => v.Streams)
+            .WithOne(s => s.MediaVersion)
+            .HasForeignKey(s => s.MediaVersionId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(v => v.Chapters)
-                .WithOne(c => c.MediaVersion)
-                .HasForeignKey(c => c.MediaVersionId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(v => v.Chapters)
+            .WithOne(c => c.MediaVersion)
+            .HasForeignKey(c => c.MediaVersionId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MovieConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MovieConfiguration.cs
index 3d1eb66d7..f86be4a06 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MovieConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MovieConfiguration.cs
@@ -2,22 +2,21 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MovieConfiguration : IEntityTypeConfiguration<Movie>
 {
-    public class MovieConfiguration : IEntityTypeConfiguration<Movie>
+    public void Configure(EntityTypeBuilder<Movie> builder)
     {
-        public void Configure(EntityTypeBuilder<Movie> builder)
-        {
-            builder.ToTable("Movie");
+        builder.ToTable("Movie");
 
-            builder.HasMany(m => m.MovieMetadata)
-                .WithOne(m => m.Movie)
-                .HasForeignKey(m => m.MovieId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(m => m.MovieMetadata)
+            .WithOne(m => m.Movie)
+            .HasForeignKey(m => m.MovieId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(m => m.MediaVersions)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(m => m.MediaVersions)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MusicVideoConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MusicVideoConfiguration.cs
index aec65afbd..d31f86b4f 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MusicVideoConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/MusicVideoConfiguration.cs
@@ -2,22 +2,21 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MusicVideoConfiguration : IEntityTypeConfiguration<MusicVideo>
 {
-    public class MusicVideoConfiguration : IEntityTypeConfiguration<MusicVideo>
+    public void Configure(EntityTypeBuilder<MusicVideo> builder)
     {
-        public void Configure(EntityTypeBuilder<MusicVideo> builder)
-        {
-            builder.ToTable("MusicVideo");
+        builder.ToTable("MusicVideo");
 
-            builder.HasMany(m => m.MusicVideoMetadata)
-                .WithOne(m => m.MusicVideo)
-                .HasForeignKey(m => m.MusicVideoId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(m => m.MusicVideoMetadata)
+            .WithOne(m => m.MusicVideo)
+            .HasForeignKey(m => m.MusicVideoId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(m => m.MediaVersions)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(m => m.MediaVersions)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/OtherVideoConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/OtherVideoConfiguration.cs
index 26c8d13eb..3bdc482bb 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/OtherVideoConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/OtherVideoConfiguration.cs
@@ -2,22 +2,21 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class OtherVideoConfiguration : IEntityTypeConfiguration<OtherVideo>
 {
-    public class OtherVideoConfiguration : IEntityTypeConfiguration<OtherVideo>
+    public void Configure(EntityTypeBuilder<OtherVideo> builder)
     {
-        public void Configure(EntityTypeBuilder<OtherVideo> builder)
-        {
-            builder.ToTable("OtherVideo");
+        builder.ToTable("OtherVideo");
 
-            builder.HasMany(m => m.OtherVideoMetadata)
-                .WithOne(m => m.OtherVideo)
-                .HasForeignKey(m => m.OtherVideoId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(m => m.OtherVideoMetadata)
+            .WithOne(m => m.OtherVideo)
+            .HasForeignKey(m => m.OtherVideoId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(m => m.MediaVersions)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(m => m.MediaVersions)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexEpisodeConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexEpisodeConfiguration.cs
index 67574162c..b90384140 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexEpisodeConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexEpisodeConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexEpisodeConfiguration : IEntityTypeConfiguration<PlexEpisode>
 {
-    public class PlexEpisodeConfiguration : IEntityTypeConfiguration<PlexEpisode>
-    {
-        public void Configure(EntityTypeBuilder<PlexEpisode> builder) => builder.ToTable("PlexEpisode");
-    }
-}
+    public void Configure(EntityTypeBuilder<PlexEpisode> builder) => builder.ToTable("PlexEpisode");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexMediaFileConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexMediaFileConfiguration.cs
index 8f7ef0fcc..ac79aaf87 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexMediaFileConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexMediaFileConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexMediaFileConfiguration : IEntityTypeConfiguration<PlexMediaFile>
 {
-    public class PlexMediaFileConfiguration : IEntityTypeConfiguration<PlexMediaFile>
-    {
-        public void Configure(EntityTypeBuilder<PlexMediaFile> builder) => builder.ToTable("PlexMediaFile");
-    }
-}
+    public void Configure(EntityTypeBuilder<PlexMediaFile> builder) => builder.ToTable("PlexMediaFile");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexMovieConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexMovieConfiguration.cs
index 454482111..b976b21c3 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexMovieConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexMovieConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexMovieConfiguration : IEntityTypeConfiguration<PlexMovie>
 {
-    public class PlexMovieConfiguration : IEntityTypeConfiguration<PlexMovie>
-    {
-        public void Configure(EntityTypeBuilder<PlexMovie> builder) => builder.ToTable("PlexMovie");
-    }
-}
+    public void Configure(EntityTypeBuilder<PlexMovie> builder) => builder.ToTable("PlexMovie");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexSeasonConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexSeasonConfiguration.cs
index 3e6eeb419..aab978e3f 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexSeasonConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexSeasonConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexSeasonConfiguration : IEntityTypeConfiguration<PlexSeason>
 {
-    public class PlexSeasonConfiguration : IEntityTypeConfiguration<PlexSeason>
-    {
-        public void Configure(EntityTypeBuilder<PlexSeason> builder) => builder.ToTable("PlexSeason");
-    }
-}
+    public void Configure(EntityTypeBuilder<PlexSeason> builder) => builder.ToTable("PlexSeason");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexShowConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexShowConfiguration.cs
index f1a9ed8c0..083ce2be9 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexShowConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/PlexShowConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexShowConfiguration : IEntityTypeConfiguration<PlexShow>
 {
-    public class PlexShowConfiguration : IEntityTypeConfiguration<PlexShow>
-    {
-        public void Configure(EntityTypeBuilder<PlexShow> builder) => builder.ToTable("PlexShow");
-    }
-}
+    public void Configure(EntityTypeBuilder<PlexShow> builder) => builder.ToTable("PlexShow");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/SeasonConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/SeasonConfiguration.cs
index 31aa60069..8e3658844 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/SeasonConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/SeasonConfiguration.cs
@@ -2,23 +2,22 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class SeasonConfiguration : IEntityTypeConfiguration<Season>
 {
-    public class SeasonConfiguration : IEntityTypeConfiguration<Season>
+    public void Configure(EntityTypeBuilder<Season> builder)
     {
-        public void Configure(EntityTypeBuilder<Season> builder)
-        {
-            builder.ToTable("Season");
+        builder.ToTable("Season");
 
-            builder.HasMany(s => s.Episodes)
-                .WithOne(e => e.Season)
-                .HasForeignKey(e => e.SeasonId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(s => s.Episodes)
+            .WithOne(e => e.Season)
+            .HasForeignKey(e => e.SeasonId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(s => s.SeasonMetadata)
-                .WithOne(s => s.Season)
-                .HasForeignKey(s => s.SeasonId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(s => s.SeasonMetadata)
+            .WithOne(s => s.Season)
+            .HasForeignKey(s => s.SeasonId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ShowConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ShowConfiguration.cs
index 52195bf23..2bcd961d9 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ShowConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/ShowConfiguration.cs
@@ -2,23 +2,22 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ShowConfiguration : IEntityTypeConfiguration<Show>
 {
-    public class ShowConfiguration : IEntityTypeConfiguration<Show>
+    public void Configure(EntityTypeBuilder<Show> builder)
     {
-        public void Configure(EntityTypeBuilder<Show> builder)
-        {
-            builder.ToTable("Show");
+        builder.ToTable("Show");
 
-            builder.HasMany(s => s.Seasons)
-                .WithOne(s => s.Show)
-                .HasForeignKey(s => s.ShowId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(s => s.Seasons)
+            .WithOne(s => s.Show)
+            .HasForeignKey(s => s.ShowId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(s => s.ShowMetadata)
-                .WithOne(s => s.Show)
-                .HasForeignKey(s => s.ShowId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(s => s.ShowMetadata)
+            .WithOne(s => s.Show)
+            .HasForeignKey(s => s.ShowId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/SongConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/SongConfiguration.cs
index abdbb36c1..6f7580e54 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/SongConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaItem/SongConfiguration.cs
@@ -2,22 +2,21 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class SongConfiguration : IEntityTypeConfiguration<Song>
 {
-    public class SongConfiguration : IEntityTypeConfiguration<Song>
+    public void Configure(EntityTypeBuilder<Song> builder)
     {
-        public void Configure(EntityTypeBuilder<Song> builder)
-        {
-            builder.ToTable("Song");
+        builder.ToTable("Song");
 
-            builder.HasMany(m => m.SongMetadata)
-                .WithOne(m => m.Song)
-                .HasForeignKey(m => m.SongId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(m => m.SongMetadata)
+            .WithOne(m => m.Song)
+            .HasForeignKey(m => m.SongId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(m => m.MediaVersions)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(m => m.MediaVersions)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyConnectionConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyConnectionConfiguration.cs
index 38f7ec1d9..c3b208b0d 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyConnectionConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyConnectionConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EmbyConnectionConfiguration : IEntityTypeConfiguration<EmbyConnection>
 {
-    public class EmbyConnectionConfiguration : IEntityTypeConfiguration<EmbyConnection>
-    {
-        public void Configure(EntityTypeBuilder<EmbyConnection> builder) =>
-            builder.ToTable("EmbyConnection");
-    }
-}
+    public void Configure(EntityTypeBuilder<EmbyConnection> builder) =>
+        builder.ToTable("EmbyConnection");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyMediaSourceConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyMediaSourceConfiguration.cs
index 6fc41ae77..cb98a4b20 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyMediaSourceConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyMediaSourceConfiguration.cs
@@ -2,23 +2,22 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EmbyMediaSourceConfiguration : IEntityTypeConfiguration<EmbyMediaSource>
 {
-    public class EmbyMediaSourceConfiguration : IEntityTypeConfiguration<EmbyMediaSource>
+    public void Configure(EntityTypeBuilder<EmbyMediaSource> builder)
     {
-        public void Configure(EntityTypeBuilder<EmbyMediaSource> builder)
-        {
-            builder.ToTable("EmbyMediaSource");
+        builder.ToTable("EmbyMediaSource");
 
-            builder.HasMany(s => s.Connections)
-                .WithOne(c => c.EmbyMediaSource)
-                .HasForeignKey(c => c.EmbyMediaSourceId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(s => s.Connections)
+            .WithOne(c => c.EmbyMediaSource)
+            .HasForeignKey(c => c.EmbyMediaSourceId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(s => s.PathReplacements)
-                .WithOne(r => r.EmbyMediaSource)
-                .HasForeignKey(r => r.EmbyMediaSourceId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(s => s.PathReplacements)
+            .WithOne(r => r.EmbyMediaSource)
+            .HasForeignKey(r => r.EmbyMediaSourceId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyPathReplacementConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyPathReplacementConfiguration.cs
index 549450237..883057092 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyPathReplacementConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/EmbyPathReplacementConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EmbyPathReplacementConfiguration : IEntityTypeConfiguration<EmbyPathReplacement>
 {
-    public class EmbyPathReplacementConfiguration : IEntityTypeConfiguration<EmbyPathReplacement>
-    {
-        public void Configure(EntityTypeBuilder<EmbyPathReplacement> builder) =>
-            builder.ToTable("EmbyPathReplacement");
-    }
-}
+    public void Configure(EntityTypeBuilder<EmbyPathReplacement> builder) =>
+        builder.ToTable("EmbyPathReplacement");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinConnectionConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinConnectionConfiguration.cs
index d93aab2c4..28f2a0ed6 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinConnectionConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinConnectionConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class JellyfinConnectionConfiguration : IEntityTypeConfiguration<JellyfinConnection>
 {
-    public class JellyfinConnectionConfiguration : IEntityTypeConfiguration<JellyfinConnection>
-    {
-        public void Configure(EntityTypeBuilder<JellyfinConnection> builder) =>
-            builder.ToTable("JellyfinConnection");
-    }
-}
+    public void Configure(EntityTypeBuilder<JellyfinConnection> builder) =>
+        builder.ToTable("JellyfinConnection");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinMediaSourceConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinMediaSourceConfiguration.cs
index 81d60f870..8478f4805 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinMediaSourceConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinMediaSourceConfiguration.cs
@@ -2,23 +2,22 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class JellyfinMediaSourceConfiguration : IEntityTypeConfiguration<JellyfinMediaSource>
 {
-    public class JellyfinMediaSourceConfiguration : IEntityTypeConfiguration<JellyfinMediaSource>
+    public void Configure(EntityTypeBuilder<JellyfinMediaSource> builder)
     {
-        public void Configure(EntityTypeBuilder<JellyfinMediaSource> builder)
-        {
-            builder.ToTable("JellyfinMediaSource");
+        builder.ToTable("JellyfinMediaSource");
 
-            builder.HasMany(s => s.Connections)
-                .WithOne(c => c.JellyfinMediaSource)
-                .HasForeignKey(c => c.JellyfinMediaSourceId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(s => s.Connections)
+            .WithOne(c => c.JellyfinMediaSource)
+            .HasForeignKey(c => c.JellyfinMediaSourceId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(s => s.PathReplacements)
-                .WithOne(r => r.JellyfinMediaSource)
-                .HasForeignKey(r => r.JellyfinMediaSourceId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(s => s.PathReplacements)
+            .WithOne(r => r.JellyfinMediaSource)
+            .HasForeignKey(r => r.JellyfinMediaSourceId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinPathReplacementConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinPathReplacementConfiguration.cs
index 649f8a29d..66b31a22c 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinPathReplacementConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/JellyfinPathReplacementConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class JellyfinPathReplacementConfiguration : IEntityTypeConfiguration<JellyfinPathReplacement>
 {
-    public class JellyfinPathReplacementConfiguration : IEntityTypeConfiguration<JellyfinPathReplacement>
-    {
-        public void Configure(EntityTypeBuilder<JellyfinPathReplacement> builder) =>
-            builder.ToTable("JellyfinPathReplacement");
-    }
-}
+    public void Configure(EntityTypeBuilder<JellyfinPathReplacement> builder) =>
+        builder.ToTable("JellyfinPathReplacement");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/LocalMediaSourceConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/LocalMediaSourceConfiguration.cs
index 9ffbced3e..605365a11 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/LocalMediaSourceConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/LocalMediaSourceConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class LocalMediaSourceConfiguration : IEntityTypeConfiguration<LocalMediaSource>
 {
-    public class LocalMediaSourceConfiguration : IEntityTypeConfiguration<LocalMediaSource>
-    {
-        public void Configure(EntityTypeBuilder<LocalMediaSource> builder) =>
-            builder.ToTable("LocalMediaSource");
-    }
-}
+    public void Configure(EntityTypeBuilder<LocalMediaSource> builder) =>
+        builder.ToTable("LocalMediaSource");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/MediaSourceConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/MediaSourceConfiguration.cs
index 92d55e5be..f975ff011 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/MediaSourceConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/MediaSourceConfiguration.cs
@@ -2,18 +2,17 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
-{
-    public class MediaSourceConfiguration : IEntityTypeConfiguration<MediaSource>
-    {
-        public void Configure(EntityTypeBuilder<MediaSource> builder)
-        {
-            builder.ToTable("MediaSource");
+namespace ErsatzTV.Infrastructure.Data.Configurations;
 
-            builder.HasMany(s => s.Libraries)
-                .WithOne(l => l.MediaSource)
-                .HasForeignKey(l => l.MediaSourceId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+public class MediaSourceConfiguration : IEntityTypeConfiguration<MediaSource>
+{
+    public void Configure(EntityTypeBuilder<MediaSource> builder)
+    {
+        builder.ToTable("MediaSource");
+
+        builder.HasMany(s => s.Libraries)
+            .WithOne(l => l.MediaSource)
+            .HasForeignKey(l => l.MediaSourceId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexConnectionConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexConnectionConfiguration.cs
index d0a100504..1ed4489e3 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexConnectionConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexConnectionConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexConnectionConfiguration : IEntityTypeConfiguration<PlexConnection>
 {
-    public class PlexConnectionConfiguration : IEntityTypeConfiguration<PlexConnection>
-    {
-        public void Configure(EntityTypeBuilder<PlexConnection> builder) =>
-            builder.ToTable("PlexConnection");
-    }
-}
+    public void Configure(EntityTypeBuilder<PlexConnection> builder) =>
+        builder.ToTable("PlexConnection");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexMediaSourceConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexMediaSourceConfiguration.cs
index ed9cc3a06..59037dea4 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexMediaSourceConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexMediaSourceConfiguration.cs
@@ -2,23 +2,22 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexMediaSourceConfiguration : IEntityTypeConfiguration<PlexMediaSource>
 {
-    public class PlexMediaSourceConfiguration : IEntityTypeConfiguration<PlexMediaSource>
+    public void Configure(EntityTypeBuilder<PlexMediaSource> builder)
     {
-        public void Configure(EntityTypeBuilder<PlexMediaSource> builder)
-        {
-            builder.ToTable("PlexMediaSource");
+        builder.ToTable("PlexMediaSource");
 
-            builder.HasMany(s => s.Connections)
-                .WithOne(c => c.PlexMediaSource)
-                .HasForeignKey(c => c.PlexMediaSourceId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(s => s.Connections)
+            .WithOne(c => c.PlexMediaSource)
+            .HasForeignKey(c => c.PlexMediaSourceId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(s => s.PathReplacements)
-                .WithOne(r => r.PlexMediaSource)
-                .HasForeignKey(r => r.PlexMediaSourceId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(s => s.PathReplacements)
+            .WithOne(r => r.PlexMediaSource)
+            .HasForeignKey(r => r.PlexMediaSourceId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexPathReplacementConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexPathReplacementConfiguration.cs
index 33e5a8c1c..42be64b15 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexPathReplacementConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/MediaSource/PlexPathReplacementConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlexPathReplacementConfiguration : IEntityTypeConfiguration<PlexPathReplacement>
 {
-    public class PlexPathReplacementConfiguration : IEntityTypeConfiguration<PlexPathReplacement>
-    {
-        public void Configure(EntityTypeBuilder<PlexPathReplacement> builder) => builder.ToTable("PlexPathReplacement");
-    }
-}
+    public void Configure(EntityTypeBuilder<PlexPathReplacement> builder) => builder.ToTable("PlexPathReplacement");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ActorConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ActorConfiguration.cs
index 0b78ac2af..a0dbeb0f5 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ActorConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ActorConfiguration.cs
@@ -2,18 +2,17 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
-{
-    public class ActorConfiguration : IEntityTypeConfiguration<Actor>
-    {
-        public void Configure(EntityTypeBuilder<Actor> builder)
-        {
-            builder.ToTable("Actor");
+namespace ErsatzTV.Infrastructure.Data.Configurations;
 
-            builder.HasOne(a => a.Artwork)
-                .WithOne()
-                .HasForeignKey<Actor>(a => a.ArtworkId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+public class ActorConfiguration : IEntityTypeConfiguration<Actor>
+{
+    public void Configure(EntityTypeBuilder<Actor> builder)
+    {
+        builder.ToTable("Actor");
+
+        builder.HasOne(a => a.Artwork)
+            .WithOne()
+            .HasForeignKey<Actor>(a => a.ArtworkId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtistMetadataConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtistMetadataConfiguration.cs
index 1c0071e7c..ee1dc0cf0 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtistMetadataConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtistMetadataConfiguration.cs
@@ -2,29 +2,28 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ArtistMetadataConfiguration : IEntityTypeConfiguration<ArtistMetadata>
 {
-    public class ArtistMetadataConfiguration : IEntityTypeConfiguration<ArtistMetadata>
+    public void Configure(EntityTypeBuilder<ArtistMetadata> builder)
     {
-        public void Configure(EntityTypeBuilder<ArtistMetadata> builder)
-        {
-            builder.ToTable("ArtistMetadata");
+        builder.ToTable("ArtistMetadata");
 
-            builder.HasMany(sm => sm.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(sm => sm.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(sm => sm.Genres)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(sm => sm.Genres)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(sm => sm.Styles)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(sm => sm.Styles)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(sm => sm.Moods)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(sm => sm.Moods)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtworkConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtworkConfiguration.cs
index f27fa2910..8bfe88cbe 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtworkConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ArtworkConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ArtworkConfiguration : IEntityTypeConfiguration<Artwork>
 {
-    public class ArtworkConfiguration : IEntityTypeConfiguration<Artwork>
-    {
-        public void Configure(EntityTypeBuilder<Artwork> builder) => builder.ToTable("Artwork");
-    }
-}
+    public void Configure(EntityTypeBuilder<Artwork> builder) => builder.ToTable("Artwork");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/DirectorConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/DirectorConfiguration.cs
index 5f6d9dd8f..5d9b05157 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/DirectorConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/DirectorConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class DirectorConfiguration : IEntityTypeConfiguration<Director>
 {
-    public class DirectorConfiguration : IEntityTypeConfiguration<Director>
-    {
-        public void Configure(EntityTypeBuilder<Director> builder) => builder.ToTable("Director");
-    }
-}
+    public void Configure(EntityTypeBuilder<Director> builder) => builder.ToTable("Director");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/EpisodeMetadataConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/EpisodeMetadataConfiguration.cs
index c00122570..28479ac17 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/EpisodeMetadataConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/EpisodeMetadataConfiguration.cs
@@ -2,33 +2,32 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class EpisodeMetadataConfiguration : IEntityTypeConfiguration<EpisodeMetadata>
 {
-    public class EpisodeMetadataConfiguration : IEntityTypeConfiguration<EpisodeMetadata>
+    public void Configure(EntityTypeBuilder<EpisodeMetadata> builder)
     {
-        public void Configure(EntityTypeBuilder<EpisodeMetadata> builder)
-        {
-            builder.ToTable("EpisodeMetadata");
+        builder.ToTable("EpisodeMetadata");
 
-            builder.HasMany(em => em.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(em => em.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(em => em.Actors)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(em => em.Actors)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Directors)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Directors)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Writers)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Writers)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Guids)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(mm => mm.Guids)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MetadataGuidConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MetadataGuidConfiguration.cs
index 9db968017..8914f72a3 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MetadataGuidConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MetadataGuidConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MetadataGuidConfiguration : IEntityTypeConfiguration<MetadataGuid>
 {
-    public class MetadataGuidConfiguration : IEntityTypeConfiguration<MetadataGuid>
-    {
-        public void Configure(EntityTypeBuilder<MetadataGuid> builder) => builder.ToTable("MetadataGuid");
-    }
-}
+    public void Configure(EntityTypeBuilder<MetadataGuid> builder) => builder.ToTable("MetadataGuid");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MovieMetadataConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MovieMetadataConfiguration.cs
index ccb43dfea..078a181a7 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MovieMetadataConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MovieMetadataConfiguration.cs
@@ -2,45 +2,44 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MovieMetadataConfiguration : IEntityTypeConfiguration<MovieMetadata>
 {
-    public class MovieMetadataConfiguration : IEntityTypeConfiguration<MovieMetadata>
+    public void Configure(EntityTypeBuilder<MovieMetadata> builder)
     {
-        public void Configure(EntityTypeBuilder<MovieMetadata> builder)
-        {
-            builder.ToTable("MovieMetadata");
+        builder.ToTable("MovieMetadata");
 
-            builder.HasMany(mm => mm.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Genres)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Genres)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Tags)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Tags)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Studios)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Studios)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Actors)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Actors)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Directors)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Directors)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Writers)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Writers)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Guids)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(mm => mm.Guids)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MusicVideoMetadataConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MusicVideoMetadataConfiguration.cs
index f52dbb9fe..87d79fa4b 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MusicVideoMetadataConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/MusicVideoMetadataConfiguration.cs
@@ -2,29 +2,28 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class MusicVideoMetadataConfiguration : IEntityTypeConfiguration<MusicVideoMetadata>
 {
-    public class MusicVideoMetadataConfiguration : IEntityTypeConfiguration<MusicVideoMetadata>
+    public void Configure(EntityTypeBuilder<MusicVideoMetadata> builder)
     {
-        public void Configure(EntityTypeBuilder<MusicVideoMetadata> builder)
-        {
-            builder.ToTable("MusicVideoMetadata");
+        builder.ToTable("MusicVideoMetadata");
 
-            builder.HasMany(mm => mm.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Genres)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Genres)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Tags)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Tags)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Studios)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(mm => mm.Studios)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/OtherVideoMetadataConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/OtherVideoMetadataConfiguration.cs
index 89d213d56..a93712231 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/OtherVideoMetadataConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/OtherVideoMetadataConfiguration.cs
@@ -2,21 +2,20 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class OtherVideoMetadataConfiguration : IEntityTypeConfiguration<OtherVideoMetadata>
 {
-    public class OtherVideoMetadataConfiguration : IEntityTypeConfiguration<OtherVideoMetadata>
+    public void Configure(EntityTypeBuilder<OtherVideoMetadata> builder)
     {
-        public void Configure(EntityTypeBuilder<OtherVideoMetadata> builder)
-        {
-            builder.ToTable("OtherVideoMetadata");
+        builder.ToTable("OtherVideoMetadata");
 
-            builder.HasMany(mm => mm.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Tags)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(mm => mm.Tags)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/SeasonMetadataConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/SeasonMetadataConfiguration.cs
index 3dedb790d..64068b46b 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/SeasonMetadataConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/SeasonMetadataConfiguration.cs
@@ -2,21 +2,20 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class SeasonMetadataConfiguration : IEntityTypeConfiguration<SeasonMetadata>
 {
-    public class SeasonMetadataConfiguration : IEntityTypeConfiguration<SeasonMetadata>
+    public void Configure(EntityTypeBuilder<SeasonMetadata> builder)
     {
-        public void Configure(EntityTypeBuilder<SeasonMetadata> builder)
-        {
-            builder.ToTable("SeasonMetadata");
+        builder.ToTable("SeasonMetadata");
 
-            builder.HasMany(em => em.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(em => em.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Guids)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(mm => mm.Guids)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ShowMetadataConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ShowMetadataConfiguration.cs
index 222d2ef70..30a38f120 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ShowMetadataConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/ShowMetadataConfiguration.cs
@@ -2,37 +2,36 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ShowMetadataConfiguration : IEntityTypeConfiguration<ShowMetadata>
 {
-    public class ShowMetadataConfiguration : IEntityTypeConfiguration<ShowMetadata>
+    public void Configure(EntityTypeBuilder<ShowMetadata> builder)
     {
-        public void Configure(EntityTypeBuilder<ShowMetadata> builder)
-        {
-            builder.ToTable("ShowMetadata");
+        builder.ToTable("ShowMetadata");
 
-            builder.HasMany(sm => sm.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(sm => sm.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(sm => sm.Genres)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(sm => sm.Genres)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(sm => sm.Tags)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(sm => sm.Tags)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(sm => sm.Studios)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(sm => sm.Studios)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(sm => sm.Actors)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(sm => sm.Actors)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Guids)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(mm => mm.Guids)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/SongMetadataConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/SongMetadataConfiguration.cs
index 2861a9545..7ac134ab6 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/SongMetadataConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/SongMetadataConfiguration.cs
@@ -2,29 +2,28 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class SongMetadataConfiguration : IEntityTypeConfiguration<SongMetadata>
 {
-    public class SongMetadataConfiguration : IEntityTypeConfiguration<SongMetadata>
+    public void Configure(EntityTypeBuilder<SongMetadata> builder)
     {
-        public void Configure(EntityTypeBuilder<SongMetadata> builder)
-        {
-            builder.ToTable("SongMetadata");
+        builder.ToTable("SongMetadata");
 
-            builder.HasMany(mm => mm.Artwork)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Artwork)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Genres)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Genres)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Tags)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(mm => mm.Tags)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(mm => mm.Studios)
-                .WithOne()
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(mm => mm.Studios)
+            .WithOne()
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/StudioConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/StudioConfiguration.cs
index bc05d575a..32682eb8b 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/StudioConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/StudioConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class StudioConfiguration : IEntityTypeConfiguration<Studio>
 {
-    public class StudioConfiguration : IEntityTypeConfiguration<Studio>
-    {
-        public void Configure(EntityTypeBuilder<Studio> builder) => builder.ToTable("Studio");
-    }
-}
+    public void Configure(EntityTypeBuilder<Studio> builder) => builder.ToTable("Studio");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/Writer.cs b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/Writer.cs
index 924ca88fe..785cd3f36 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/Metadata/Writer.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/Metadata/Writer.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class WriterConfiguration : IEntityTypeConfiguration<Writer>
 {
-    public class WriterConfiguration : IEntityTypeConfiguration<Writer>
-    {
-        public void Configure(EntityTypeBuilder<Writer> builder) => builder.ToTable("Writer");
-    }
-}
+    public void Configure(EntityTypeBuilder<Writer> builder) => builder.ToTable("Writer");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/PlayoutConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/PlayoutConfiguration.cs
index ea9853065..0ec88132c 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/PlayoutConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/PlayoutConfiguration.cs
@@ -2,28 +2,27 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlayoutConfiguration : IEntityTypeConfiguration<Playout>
 {
-    public class PlayoutConfiguration : IEntityTypeConfiguration<Playout>
+    public void Configure(EntityTypeBuilder<Playout> builder)
     {
-        public void Configure(EntityTypeBuilder<Playout> builder)
-        {
-            builder.ToTable("Playout");
+        builder.ToTable("Playout");
 
-            builder.HasMany(p => p.Items)
-                .WithOne(pi => pi.Playout)
-                .HasForeignKey(pi => pi.PlayoutId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(p => p.Items)
+            .WithOne(pi => pi.Playout)
+            .HasForeignKey(pi => pi.PlayoutId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.OwnsOne(p => p.Anchor)
-                .ToTable("PlayoutAnchor")
-                .OwnsOne(a => a.ScheduleItemsEnumeratorState)
-                .ToTable("ScheduleItemsEnumeratorState");
+        builder.OwnsOne(p => p.Anchor)
+            .ToTable("PlayoutAnchor")
+            .OwnsOne(a => a.ScheduleItemsEnumeratorState)
+            .ToTable("ScheduleItemsEnumeratorState");
 
-            builder.HasMany(p => p.ProgramScheduleAnchors)
-                .WithOne(a => a.Playout)
-                .HasForeignKey(a => a.PlayoutId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(p => p.ProgramScheduleAnchors)
+            .WithOne(a => a.Playout)
+            .HasForeignKey(a => a.PlayoutId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/PlayoutItemConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/PlayoutItemConfiguration.cs
index f14989239..acf51c2f0 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/PlayoutItemConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/PlayoutItemConfiguration.cs
@@ -2,19 +2,18 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlayoutItemConfiguration : IEntityTypeConfiguration<PlayoutItem>
+
 {
-    public class PlayoutItemConfiguration : IEntityTypeConfiguration<PlayoutItem>
-
+    public void Configure(EntityTypeBuilder<PlayoutItem> builder)
     {
-        public void Configure(EntityTypeBuilder<PlayoutItem> builder)
-        {
-            builder.ToTable("PlayoutItem");
+        builder.ToTable("PlayoutItem");
 
-            builder.HasOne(pi => pi.MediaItem)
-                .WithMany()
-                .HasForeignKey(pi => pi.MediaItemId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasOne(pi => pi.MediaItem)
+            .WithMany()
+            .HasForeignKey(pi => pi.MediaItemId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/PlayoutProgramScheduleAnchorConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/PlayoutProgramScheduleAnchorConfiguration.cs
index d30e4d293..660bf2308 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/PlayoutProgramScheduleAnchorConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/PlayoutProgramScheduleAnchorConfiguration.cs
@@ -2,33 +2,32 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class PlayoutProgramScheduleAnchorConfiguration : IEntityTypeConfiguration<PlayoutProgramScheduleAnchor>
 {
-    public class PlayoutProgramScheduleAnchorConfiguration : IEntityTypeConfiguration<PlayoutProgramScheduleAnchor>
+    public void Configure(EntityTypeBuilder<PlayoutProgramScheduleAnchor> builder)
     {
-        public void Configure(EntityTypeBuilder<PlayoutProgramScheduleAnchor> builder)
-        {
-            builder.ToTable("PlayoutProgramScheduleAnchor");
+        builder.ToTable("PlayoutProgramScheduleAnchor");
 
-            builder.OwnsOne(a => a.EnumeratorState).ToTable("CollectionEnumeratorState");
+        builder.OwnsOne(a => a.EnumeratorState).ToTable("CollectionEnumeratorState");
 
-            builder.HasOne(i => i.Collection)
-                .WithMany()
-                .HasForeignKey(i => i.CollectionId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.Collection)
+            .WithMany()
+            .HasForeignKey(i => i.CollectionId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.MultiCollection)
-                .WithMany()
-                .HasForeignKey(i => i.MultiCollectionId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.MultiCollection)
+            .WithMany()
+            .HasForeignKey(i => i.MultiCollectionId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.MediaItem)
-                .WithMany()
-                .HasForeignKey(i => i.MediaItemId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
-        }
+        builder.HasOne(i => i.MediaItem)
+            .WithMany()
+            .HasForeignKey(i => i.MediaItemId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleConfiguration.cs
index e93a3a3ce..a99960027 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleConfiguration.cs
@@ -2,26 +2,25 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ProgramScheduleConfiguration : IEntityTypeConfiguration<ProgramSchedule>
 {
-    public class ProgramScheduleConfiguration : IEntityTypeConfiguration<ProgramSchedule>
+    public void Configure(EntityTypeBuilder<ProgramSchedule> builder)
     {
-        public void Configure(EntityTypeBuilder<ProgramSchedule> builder)
-        {
-            builder.ToTable("ProgramSchedule");
+        builder.ToTable("ProgramSchedule");
 
-            builder.HasIndex(ps => ps.Name)
-                .IsUnique();
+        builder.HasIndex(ps => ps.Name)
+            .IsUnique();
 
-            builder.HasMany(ps => ps.Items)
-                .WithOne(i => i.ProgramSchedule)
-                .HasForeignKey(i => i.ProgramScheduleId)
-                .OnDelete(DeleteBehavior.Cascade);
+        builder.HasMany(ps => ps.Items)
+            .WithOne(i => i.ProgramSchedule)
+            .HasForeignKey(i => i.ProgramScheduleId)
+            .OnDelete(DeleteBehavior.Cascade);
 
-            builder.HasMany(ps => ps.Playouts)
-                .WithOne(p => p.ProgramSchedule)
-                .HasForeignKey(p => p.ProgramScheduleId)
-                .OnDelete(DeleteBehavior.Cascade);
-        }
+        builder.HasMany(ps => ps.Playouts)
+            .WithOne(p => p.ProgramSchedule)
+            .HasForeignKey(p => p.ProgramScheduleId)
+            .OnDelete(DeleteBehavior.Cascade);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemConfiguration.cs
index 99306e868..6480ec0ff 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemConfiguration.cs
@@ -2,67 +2,66 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ProgramScheduleItemConfiguration : IEntityTypeConfiguration<ProgramScheduleItem>
 {
-    public class ProgramScheduleItemConfiguration : IEntityTypeConfiguration<ProgramScheduleItem>
+    public void Configure(EntityTypeBuilder<ProgramScheduleItem> builder)
     {
-        public void Configure(EntityTypeBuilder<ProgramScheduleItem> builder)
-        {
-            builder.ToTable("ProgramScheduleItem");
+        builder.ToTable("ProgramScheduleItem");
 
-            builder.HasOne(i => i.Collection)
-                .WithMany()
-                .HasForeignKey(i => i.CollectionId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.Collection)
+            .WithMany()
+            .HasForeignKey(i => i.CollectionId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.MediaItem)
-                .WithMany()
-                .HasForeignKey(i => i.MediaItemId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.MediaItem)
+            .WithMany()
+            .HasForeignKey(i => i.MediaItemId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.MultiCollection)
-                .WithMany()
-                .HasForeignKey(i => i.MultiCollectionId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.MultiCollection)
+            .WithMany()
+            .HasForeignKey(i => i.MultiCollectionId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.SmartCollection)
-                .WithMany()
-                .HasForeignKey(i => i.SmartCollectionId)
-                .OnDelete(DeleteBehavior.Cascade)
-                .IsRequired(false);
+        builder.HasOne(i => i.SmartCollection)
+            .WithMany()
+            .HasForeignKey(i => i.SmartCollectionId)
+            .OnDelete(DeleteBehavior.Cascade)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.PreRollFiller)
-                .WithMany()
-                .HasForeignKey(i => i.PreRollFillerId)
-                .OnDelete(DeleteBehavior.SetNull)
-                .IsRequired(false);
+        builder.HasOne(i => i.PreRollFiller)
+            .WithMany()
+            .HasForeignKey(i => i.PreRollFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.MidRollFiller)
-                .WithMany()
-                .HasForeignKey(i => i.MidRollFillerId)
-                .OnDelete(DeleteBehavior.SetNull)
-                .IsRequired(false);
+        builder.HasOne(i => i.MidRollFiller)
+            .WithMany()
+            .HasForeignKey(i => i.MidRollFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.PostRollFiller)
-                .WithMany()
-                .HasForeignKey(i => i.PostRollFillerId)
-                .OnDelete(DeleteBehavior.SetNull)
-                .IsRequired(false);
+        builder.HasOne(i => i.PostRollFiller)
+            .WithMany()
+            .HasForeignKey(i => i.PostRollFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.TailFiller)
-                .WithMany()
-                .HasForeignKey(i => i.TailFillerId)
-                .OnDelete(DeleteBehavior.SetNull)
-                .IsRequired(false);
+        builder.HasOne(i => i.TailFiller)
+            .WithMany()
+            .HasForeignKey(i => i.TailFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
 
-            builder.HasOne(i => i.FallbackFiller)
-                .WithMany()
-                .HasForeignKey(i => i.FallbackFillerId)
-                .OnDelete(DeleteBehavior.SetNull)
-                .IsRequired(false);
-        }
+        builder.HasOne(i => i.FallbackFiller)
+            .WithMany()
+            .HasForeignKey(i => i.FallbackFillerId)
+            .OnDelete(DeleteBehavior.SetNull)
+            .IsRequired(false);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemDurationConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemDurationConfiguration.cs
index cdf510dd0..536e58852 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemDurationConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemDurationConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ProgramScheduleItemDurationConfiguration : IEntityTypeConfiguration<ProgramScheduleItemDuration>
 {
-    public class ProgramScheduleItemDurationConfiguration : IEntityTypeConfiguration<ProgramScheduleItemDuration>
-    {
-        public void Configure(EntityTypeBuilder<ProgramScheduleItemDuration> builder) =>
-            builder.ToTable("ProgramScheduleDurationItem");
-    }
-}
+    public void Configure(EntityTypeBuilder<ProgramScheduleItemDuration> builder) =>
+        builder.ToTable("ProgramScheduleDurationItem");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemFloodConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemFloodConfiguration.cs
index c58329ecd..4abbd122d 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemFloodConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemFloodConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ProgramScheduleItemFloodConfiguration : IEntityTypeConfiguration<ProgramScheduleItemFlood>
 {
-    public class ProgramScheduleItemFloodConfiguration : IEntityTypeConfiguration<ProgramScheduleItemFlood>
-    {
-        public void Configure(EntityTypeBuilder<ProgramScheduleItemFlood> builder) =>
-            builder.ToTable("ProgramScheduleFloodItem");
-    }
-}
+    public void Configure(EntityTypeBuilder<ProgramScheduleItemFlood> builder) =>
+        builder.ToTable("ProgramScheduleFloodItem");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemMultipleConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemMultipleConfiguration.cs
index c2117e5b8..479249989 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemMultipleConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemMultipleConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ProgramScheduleItemMultipleConfiguration : IEntityTypeConfiguration<ProgramScheduleItemMultiple>
 {
-    public class ProgramScheduleItemMultipleConfiguration : IEntityTypeConfiguration<ProgramScheduleItemMultiple>
-    {
-        public void Configure(EntityTypeBuilder<ProgramScheduleItemMultiple> builder) =>
-            builder.ToTable("ProgramScheduleMultipleItem");
-    }
-}
+    public void Configure(EntityTypeBuilder<ProgramScheduleItemMultiple> builder) =>
+        builder.ToTable("ProgramScheduleMultipleItem");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemOneConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemOneConfiguration.cs
index 20376f3ce..954a3a4cc 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemOneConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ProgramScheduleItemOneConfiguration.cs
@@ -2,11 +2,10 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ProgramScheduleItemOneConfiguration : IEntityTypeConfiguration<ProgramScheduleItemOne>
 {
-    public class ProgramScheduleItemOneConfiguration : IEntityTypeConfiguration<ProgramScheduleItemOne>
-    {
-        public void Configure(EntityTypeBuilder<ProgramScheduleItemOne> builder) =>
-            builder.ToTable("ProgramScheduleOneItem");
-    }
-}
+    public void Configure(EntityTypeBuilder<ProgramScheduleItemOne> builder) =>
+        builder.ToTable("ProgramScheduleOneItem");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Configurations/ResolutionConfiguration.cs b/ErsatzTV.Infrastructure/Data/Configurations/ResolutionConfiguration.cs
index 49c35ab91..0875b37b0 100644
--- a/ErsatzTV.Infrastructure/Data/Configurations/ResolutionConfiguration.cs
+++ b/ErsatzTV.Infrastructure/Data/Configurations/ResolutionConfiguration.cs
@@ -2,10 +2,9 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace ErsatzTV.Infrastructure.Data.Configurations
+namespace ErsatzTV.Infrastructure.Data.Configurations;
+
+public class ResolutionConfiguration : IEntityTypeConfiguration<Resolution>
 {
-    public class ResolutionConfiguration : IEntityTypeConfiguration<Resolution>
-    {
-        public void Configure(EntityTypeBuilder<Resolution> builder) => builder.ToTable("Resolution");
-    }
-}
+    public void Configure(EntityTypeBuilder<Resolution> builder) => builder.ToTable("Resolution");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/DbInitializer.cs b/ErsatzTV.Infrastructure/Data/DbInitializer.cs
index 30709077e..a6cda92bc 100644
--- a/ErsatzTV.Infrastructure/Data/DbInitializer.cs
+++ b/ErsatzTV.Infrastructure/Data/DbInitializer.cs
@@ -1,103 +1,95 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Reflection;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 
-namespace ErsatzTV.Infrastructure.Data
+namespace ErsatzTV.Infrastructure.Data;
+
+public static class DbInitializer
 {
-    public static class DbInitializer
+    public static async Task<Unit> Initialize(TvContext context, CancellationToken cancellationToken)
     {
-        public static async Task<Unit> Initialize(TvContext context, CancellationToken cancellationToken)
+        if (!context.LanguageCodes.Any())
         {
-            if (!context.LanguageCodes.Any())
+            var assembly = Assembly.GetEntryAssembly();
+            if (assembly != null)
             {
-                var assembly = Assembly.GetEntryAssembly();
-                if (assembly != null)
+                await using Stream resource =
+                    assembly.GetManifestResourceStream("ErsatzTV.Resources.ISO-639-2_utf-8.txt");
+                if (resource != null)
                 {
-                    await using Stream resource =
-                        assembly.GetManifestResourceStream("ErsatzTV.Resources.ISO-639-2_utf-8.txt");
-                    if (resource != null)
+                    using var reader = new StreamReader(resource);
+                    while (!reader.EndOfStream)
                     {
-                        using var reader = new StreamReader(resource);
-                        while (!reader.EndOfStream)
+                        string line = await reader.ReadLineAsync();
+                        if (line != null)
                         {
-                            string line = await reader.ReadLineAsync();
-                            if (line != null)
+                            string[] split = line.Split("|");
+                            if (split.Length == 5)
                             {
-                                string[] split = line.Split("|");
-                                if (split.Length == 5)
+                                var languageCode = new LanguageCode
                                 {
-                                    var languageCode = new LanguageCode
-                                    {
-                                        ThreeCode1 = split[0],
-                                        ThreeCode2 = split[1],
-                                        TwoCode = split[2],
-                                        EnglishName = split[3],
-                                        FrenchName = split[4]
-                                    };
+                                    ThreeCode1 = split[0],
+                                    ThreeCode2 = split[1],
+                                    TwoCode = split[2],
+                                    EnglishName = split[3],
+                                    FrenchName = split[4]
+                                };
 
-                                    await context.LanguageCodes.AddAsync(languageCode, cancellationToken);
-                                }
+                                await context.LanguageCodes.AddAsync(languageCode, cancellationToken);
                             }
                         }
                     }
                 }
-
-                await context.SaveChangesAsync(cancellationToken);
             }
 
-            if (context.Resolutions.Any())
-            {
-                return Unit.Default;
-            }
-
-            var resolutions = new List<Resolution>
-            {
-                new() { Id = 1, Name = "720x480", Width = 720, Height = 480 },
-                new() { Id = 2, Name = "1280x720", Width = 1280, Height = 720 },
-                new() { Id = 3, Name = "1920x1080", Width = 1920, Height = 1080 },
-                new() { Id = 4, Name = "3840x2160", Width = 3840, Height = 2160 }
-            };
-            await context.Resolutions.AddRangeAsync(resolutions, cancellationToken);
             await context.SaveChangesAsync(cancellationToken);
+        }
 
-            var resolutionConfig = new ConfigElement
-            {
-                Key = ConfigElementKey.FFmpegDefaultResolutionId.Key,
-                Value = "3" // 1920x1080
-            };
-            await context.ConfigElements.AddAsync(resolutionConfig, cancellationToken);
-            await context.SaveChangesAsync(cancellationToken);
-
-            var defaultProfile = FFmpegProfile.New("1920x1080 x264 ac3", resolutions[2]);
-            await context.FFmpegProfiles.AddAsync(defaultProfile, cancellationToken);
-            await context.SaveChangesAsync(cancellationToken);
-
-            var profileConfig = new ConfigElement
-            {
-                Key = ConfigElementKey.FFmpegDefaultProfileId.Key,
-                Value = defaultProfile.Id.ToString()
-            };
-            await context.ConfigElements.AddAsync(profileConfig, cancellationToken);
-            await context.SaveChangesAsync(cancellationToken);
-
-            var defaultChannel = new Channel(Guid.NewGuid())
-            {
-                Number = "1",
-                Name = "ErsatzTV",
-                FFmpegProfile = defaultProfile,
-                StreamingMode = StreamingMode.TransportStream
-            };
-            await context.Channels.AddAsync(defaultChannel, cancellationToken);
-            await context.SaveChangesAsync(cancellationToken);
-
-            // TODO: create looping static image that mentions configuring via web
+        if (context.Resolutions.Any())
+        {
             return Unit.Default;
         }
+
+        var resolutions = new List<Resolution>
+        {
+            new() { Id = 1, Name = "720x480", Width = 720, Height = 480 },
+            new() { Id = 2, Name = "1280x720", Width = 1280, Height = 720 },
+            new() { Id = 3, Name = "1920x1080", Width = 1920, Height = 1080 },
+            new() { Id = 4, Name = "3840x2160", Width = 3840, Height = 2160 }
+        };
+        await context.Resolutions.AddRangeAsync(resolutions, cancellationToken);
+        await context.SaveChangesAsync(cancellationToken);
+
+        var resolutionConfig = new ConfigElement
+        {
+            Key = ConfigElementKey.FFmpegDefaultResolutionId.Key,
+            Value = "3" // 1920x1080
+        };
+        await context.ConfigElements.AddAsync(resolutionConfig, cancellationToken);
+        await context.SaveChangesAsync(cancellationToken);
+
+        var defaultProfile = FFmpegProfile.New("1920x1080 x264 ac3", resolutions[2]);
+        await context.FFmpegProfiles.AddAsync(defaultProfile, cancellationToken);
+        await context.SaveChangesAsync(cancellationToken);
+
+        var profileConfig = new ConfigElement
+        {
+            Key = ConfigElementKey.FFmpegDefaultProfileId.Key,
+            Value = defaultProfile.Id.ToString()
+        };
+        await context.ConfigElements.AddAsync(profileConfig, cancellationToken);
+        await context.SaveChangesAsync(cancellationToken);
+
+        var defaultChannel = new Channel(Guid.NewGuid())
+        {
+            Number = "1",
+            Name = "ErsatzTV",
+            FFmpegProfile = defaultProfile,
+            StreamingMode = StreamingMode.TransportStream
+        };
+        await context.Channels.AddAsync(defaultChannel, cancellationToken);
+        await context.SaveChangesAsync(cancellationToken);
+
+        // TODO: create looping static image that mentions configuring via web
+        return Unit.Default;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/LogContext.cs b/ErsatzTV.Infrastructure/Data/LogContext.cs
index 67680cd93..1915f6491 100644
--- a/ErsatzTV.Infrastructure/Data/LogContext.cs
+++ b/ErsatzTV.Infrastructure/Data/LogContext.cs
@@ -1,21 +1,20 @@
 using ErsatzTV.Core.Domain;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Infrastructure.Data
+namespace ErsatzTV.Infrastructure.Data;
+
+public class LogContext : DbContext
 {
-    public class LogContext : DbContext
+    public LogContext(DbContextOptions<LogContext> options)
+        : base(options)
     {
-        public LogContext(DbContextOptions<LogContext> options)
-            : base(options)
-        {
-        }
-
-        public DbSet<LogEntry> LogEntries { get; set; }
-
-        protected override void OnModelCreating(ModelBuilder builder)
-        {
-            base.OnModelCreating(builder);
-            builder.Entity<LogEntry>().ToTable("Logs");
-        }
     }
-}
+
+    public DbSet<LogEntry> LogEntries { get; set; }
+
+    protected override void OnModelCreating(ModelBuilder builder)
+    {
+        base.OnModelCreating(builder);
+        builder.Entity<LogEntry>().ToTable("Logs");
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/ArtistRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/ArtistRepository.cs
index 709bac78c..f3becab14 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/ArtistRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/ArtistRepository.cs
@@ -1,177 +1,170 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class ArtistRepository : IArtistRepository
 {
-    public class ArtistRepository : IArtistRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public ArtistRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public ArtistRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<Option<Artist>> GetArtistByMetadata(int libraryPathId, ArtistMetadata metadata)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<int> maybeId = await dbContext.ArtistMetadata
+            .Where(
+                s => s.Title == metadata.Title && (metadata.MetadataKind == MetadataKind.Fallback ||
+                                                   s.Disambiguation == metadata.Disambiguation))
+            .Where(s => s.Artist.LibraryPathId == libraryPathId)
+            .SingleOrDefaultAsync()
+            .Map(Optional)
+            .MapT(sm => sm.ArtistId);
 
-        public async Task<Option<Artist>> GetArtistByMetadata(int libraryPathId, ArtistMetadata metadata)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<int> maybeId = await dbContext.ArtistMetadata
-                .Where(
-                    s => s.Title == metadata.Title && (metadata.MetadataKind == MetadataKind.Fallback ||
-                                                       s.Disambiguation == metadata.Disambiguation))
-                .Where(s => s.Artist.LibraryPathId == libraryPathId)
-                .SingleOrDefaultAsync()
-                .Map(Optional)
-                .MapT(sm => sm.ArtistId);
-
-            return await maybeId.Match(
-                id =>
-                {
-                    return dbContext.Artists
-                        .AsNoTracking()
-                        .Include(s => s.ArtistMetadata)
-                        .ThenInclude(sm => sm.Artwork)
-                        .Include(s => s.ArtistMetadata)
-                        .ThenInclude(sm => sm.Genres)
-                        .Include(s => s.ArtistMetadata)
-                        .ThenInclude(sm => sm.Styles)
-                        .Include(s => s.ArtistMetadata)
-                        .ThenInclude(sm => sm.Moods)
-                        .Include(s => s.LibraryPath)
-                        .ThenInclude(lp => lp.Library)
-                        .OrderBy(s => s.Id)
-                        .SingleOrDefaultAsync(s => s.Id == id)
-                        .Map(Optional);
-                },
-                () => Option<Artist>.None.AsTask());
-        }
-
-        public async Task<Either<BaseError, MediaItemScanResult<Artist>>> AddArtist(
-            int libraryPathId,
-            string artistFolder,
-            ArtistMetadata metadata)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            try
+        return await maybeId.Match(
+            id =>
             {
-                metadata.DateAdded = DateTime.UtcNow;
-                metadata.Genres ??= new List<Genre>();
-                metadata.Styles ??= new List<Style>();
-                metadata.Moods ??= new List<Mood>();
-                var artist = new Artist
-                {
-                    LibraryPathId = libraryPathId,
-                    ArtistMetadata = new List<ArtistMetadata> { metadata }
-                };
+                return dbContext.Artists
+                    .AsNoTracking()
+                    .Include(s => s.ArtistMetadata)
+                    .ThenInclude(sm => sm.Artwork)
+                    .Include(s => s.ArtistMetadata)
+                    .ThenInclude(sm => sm.Genres)
+                    .Include(s => s.ArtistMetadata)
+                    .ThenInclude(sm => sm.Styles)
+                    .Include(s => s.ArtistMetadata)
+                    .ThenInclude(sm => sm.Moods)
+                    .Include(s => s.LibraryPath)
+                    .ThenInclude(lp => lp.Library)
+                    .OrderBy(s => s.Id)
+                    .SingleOrDefaultAsync(s => s.Id == id)
+                    .Map(Optional);
+            },
+            () => Option<Artist>.None.AsTask());
+    }
 
-                await dbContext.Artists.AddAsync(artist);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(artist).Reference(s => s.LibraryPath).LoadAsync();
-                await dbContext.Entry(artist.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+    public async Task<Either<BaseError, MediaItemScanResult<Artist>>> AddArtist(
+        int libraryPathId,
+        string artistFolder,
+        ArtistMetadata metadata)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-                return new MediaItemScanResult<Artist>(artist) { IsAdded = true };
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        public async Task<List<int>> DeleteEmptyArtists(LibraryPath libraryPath)
+        try
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<Artist> artists = await dbContext.Artists
-                .Filter(a => a.LibraryPathId == libraryPath.Id)
-                .Filter(a => a.MusicVideos.Count == 0)
-                .ToListAsync();
-            var ids = artists.Map(a => a.Id).ToList();
-            dbContext.Artists.RemoveRange(artists);
+            metadata.DateAdded = DateTime.UtcNow;
+            metadata.Genres ??= new List<Genre>();
+            metadata.Styles ??= new List<Style>();
+            metadata.Moods ??= new List<Mood>();
+            var artist = new Artist
+            {
+                LibraryPathId = libraryPathId,
+                ArtistMetadata = new List<ArtistMetadata> { metadata }
+            };
+
+            await dbContext.Artists.AddAsync(artist);
             await dbContext.SaveChangesAsync();
-            return ids;
+            await dbContext.Entry(artist).Reference(s => s.LibraryPath).LoadAsync();
+            await dbContext.Entry(artist.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+
+            return new MediaItemScanResult<Artist>(artist) { IsAdded = true };
         }
-
-        public async Task<Option<Artist>> GetArtist(int artistId)
+        catch (Exception ex)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Artists
-                .Include(m => m.ArtistMetadata)
-                .ThenInclude(m => m.Artwork)
-                .Include(m => m.ArtistMetadata)
-                .ThenInclude(m => m.Genres)
-                .Include(m => m.ArtistMetadata)
-                .ThenInclude(m => m.Styles)
-                .Include(m => m.ArtistMetadata)
-                .ThenInclude(m => m.Moods)
-                .OrderBy(m => m.Id)
-                .SingleOrDefaultAsync(m => m.Id == artistId)
-                .Map(Optional);
-        }
-
-        public async Task<List<ArtistMetadata>> GetArtistsForCards(List<int> ids)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.ArtistMetadata
-                .AsNoTracking()
-                .Filter(am => ids.Contains(am.ArtistId))
-                .Include(am => am.Artist)
-                .Include(am => am.Artwork)
-                .OrderBy(am => am.SortTitle)
-                .ToListAsync();
-        }
-
-        public Task<bool> AddGenre(ArtistMetadata metadata, Genre genre) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Genre (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
-                new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddStyle(ArtistMetadata metadata, Style style) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Style (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
-                new { style.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddMood(ArtistMetadata metadata, Mood mood) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Mood (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
-                new { mood.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public async Task<List<MusicVideo>> GetArtistItems(int artistId)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.MusicVideos
-                .AsNoTracking()
-                .Include(mv => mv.MusicVideoMetadata)
-                .Include(mv => mv.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(mv => mv.Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .Filter(mv => mv.ArtistId == artistId)
-                .ToListAsync();
-        }
-
-        public async Task<List<Artist>> GetAllArtists()
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Artists
-                .AsNoTracking()
-                .Include(a => a.ArtistMetadata)
-                .ThenInclude(am => am.Artwork)
-                .ToListAsync();
+            return BaseError.New(ex.Message);
         }
     }
-}
+
+    public async Task<List<int>> DeleteEmptyArtists(LibraryPath libraryPath)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<Artist> artists = await dbContext.Artists
+            .Filter(a => a.LibraryPathId == libraryPath.Id)
+            .Filter(a => a.MusicVideos.Count == 0)
+            .ToListAsync();
+        var ids = artists.Map(a => a.Id).ToList();
+        dbContext.Artists.RemoveRange(artists);
+        await dbContext.SaveChangesAsync();
+        return ids;
+    }
+
+    public async Task<Option<Artist>> GetArtist(int artistId)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Artists
+            .Include(m => m.ArtistMetadata)
+            .ThenInclude(m => m.Artwork)
+            .Include(m => m.ArtistMetadata)
+            .ThenInclude(m => m.Genres)
+            .Include(m => m.ArtistMetadata)
+            .ThenInclude(m => m.Styles)
+            .Include(m => m.ArtistMetadata)
+            .ThenInclude(m => m.Moods)
+            .OrderBy(m => m.Id)
+            .SingleOrDefaultAsync(m => m.Id == artistId)
+            .Map(Optional);
+    }
+
+    public async Task<List<ArtistMetadata>> GetArtistsForCards(List<int> ids)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.ArtistMetadata
+            .AsNoTracking()
+            .Filter(am => ids.Contains(am.ArtistId))
+            .Include(am => am.Artist)
+            .Include(am => am.Artwork)
+            .OrderBy(am => am.SortTitle)
+            .ToListAsync();
+    }
+
+    public Task<bool> AddGenre(ArtistMetadata metadata, Genre genre) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Genre (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
+            new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddStyle(ArtistMetadata metadata, Style style) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Style (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
+            new { style.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddMood(ArtistMetadata metadata, Mood mood) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Mood (Name, ArtistMetadataId) VALUES (@Name, @MetadataId)",
+            new { mood.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public async Task<List<MusicVideo>> GetArtistItems(int artistId)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.MusicVideos
+            .AsNoTracking()
+            .Include(mv => mv.MusicVideoMetadata)
+            .Include(mv => mv.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(mv => mv.Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .Filter(mv => mv.ArtistId == artistId)
+            .ToListAsync();
+    }
+
+    public async Task<List<Artist>> GetAllArtists()
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Artists
+            .AsNoTracking()
+            .Include(a => a.ArtistMetadata)
+            .ThenInclude(am => am.Artwork)
+            .ToListAsync();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/ArtworkRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/ArtworkRepository.cs
index 725faf368..2390b2427 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/ArtworkRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/ArtworkRepository.cs
@@ -1,61 +1,56 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class ArtworkRepository : IArtworkRepository
 {
-    public class ArtworkRepository : IArtworkRepository
-    {
-        private readonly IDbConnection _dbConnection;
+    private readonly IDbConnection _dbConnection;
 
-        public ArtworkRepository(IDbConnection dbConnection) => _dbConnection = dbConnection;
+    public ArtworkRepository(IDbConnection dbConnection) => _dbConnection = dbConnection;
 
-        public Task<List<Artwork>> GetOrphanedArtwork() =>
-            _dbConnection.QueryAsync<Artwork>(
-                    @"SELECT A.Id, A.Path FROM Artwork A
+    public Task<List<Artwork>> GetOrphanedArtwork() =>
+        _dbConnection.QueryAsync<Artwork>(
+                @"SELECT A.Id, A.Path FROM Artwork A
                       WHERE A.ArtistMetadataId IS NULL AND A.EpisodeMetadataId IS NULL
                       AND A.SeasonMetadataId IS NULL AND A.ShowMetadataId IS NULL
                       AND A.MovieMetadataId IS NULL AND A.MusicVideoMetadataId IS NULL
                       AND A.SongMetadataId IS NULL AND A.ChannelId IS NULL
                       AND NOT EXISTS (SELECT * FROM Actor WHERE Actor.ArtworkId = A.Id)")
-                .Map(result => result.ToList());
+            .Map(result => result.ToList());
 
-        public async Task<Unit> Delete(List<Artwork> artwork)
+    public async Task<Unit> Delete(List<Artwork> artwork)
+    {
+        IEnumerable<List<int>> chunks = Chunk(artwork.Map(a => a.Id), 100);
+        foreach (List<int> chunk in chunks)
         {
-            IEnumerable<List<int>> chunks = Chunk(artwork.Map(a => a.Id), 100);
-            foreach (List<int> chunk in chunks)
-            {
-                await _dbConnection.ExecuteAsync(
-                    "DELETE FROM Artwork WHERE Id IN @Ids",
-                    new { Ids = chunk });
-            }
-
-            return Unit.Default;
+            await _dbConnection.ExecuteAsync(
+                "DELETE FROM Artwork WHERE Id IN @Ids",
+                new { Ids = chunk });
         }
 
-        private static IEnumerable<List<T>> Chunk<T>(IEnumerable<T> collection, int size)
-        {
-            var count = 0;
-            var chunk = new List<T>(size);
-
-            foreach (T element in collection)
-            {
-                if (count++ == size)
-                {
-                    yield return chunk;
-                    chunk = new List<T>(size);
-                    count = 1;
-                }
-
-                chunk.Add(element);
-            }
-
-            yield return chunk;
-        }
+        return Unit.Default;
     }
-}
+
+    private static IEnumerable<List<T>> Chunk<T>(IEnumerable<T> collection, int size)
+    {
+        var count = 0;
+        var chunk = new List<T>(size);
+
+        foreach (T element in collection)
+        {
+            if (count++ == size)
+            {
+                yield return chunk;
+                chunk = new List<T>(size);
+                count = 1;
+            }
+
+            chunk.Add(element);
+        }
+
+        yield return chunk;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/ChannelRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/ChannelRepository.cs
index 2b027efd1..47eb3eec1 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/ChannelRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/ChannelRepository.cs
@@ -1,124 +1,117 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
+namespace ErsatzTV.Infrastructure.Data.Repositories;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+public class ChannelRepository : IChannelRepository
 {
-    public class ChannelRepository : IChannelRepository
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public ChannelRepository(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Option<Channel>> Get(int id)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public ChannelRepository(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
-
-        public async Task<Option<Channel>> Get(int id)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Channels
-                .Include(c => c.Artwork)
-                .Include(c => c.Watermark)
-                .OrderBy(c => c.Id)
-                .SingleOrDefaultAsync(c => c.Id == id)
-                .Map(Optional);
-        }
-
-        public async Task<Option<Channel>> GetByNumber(string number)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Channels
-                .Include(c => c.FFmpegProfile)
-                .ThenInclude(p => p.Resolution)
-                .Include(c => c.Artwork)
-                .Include(c => c.Watermark)
-                .OrderBy(c => c.Number)
-                .SingleOrDefaultAsync(c => c.Number == number)
-                .Map(Optional);
-        }
-
-        public async Task<List<Channel>> GetAll()
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Channels
-                .Include(c => c.FFmpegProfile)
-                .Include(c => c.Artwork)
-                .Include(c => c.Playouts)
-                .ToListAsync();
-        }
-
-        public async Task<List<Channel>> GetAllForGuide()
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Channels
-                .Include(c => c.Artwork)
-                .Include(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .Include(c => c.Playouts)
-                .ThenInclude(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(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(em => em.Genres)
-                .Include(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Genres)
-                .Include(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .ThenInclude(am => am.Genres)
-                .Include(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(c => c.Playouts)
-                .ThenInclude(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .ToListAsync();
-        }
-
-        public async Task Delete(int channelId)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Channel channel = await dbContext.Channels.FindAsync(channelId);
-            dbContext.Channels.Remove(channel);
-            await dbContext.SaveChangesAsync();
-        }
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Channels
+            .Include(c => c.Artwork)
+            .Include(c => c.Watermark)
+            .OrderBy(c => c.Id)
+            .SingleOrDefaultAsync(c => c.Id == id)
+            .Map(Optional);
     }
-}
+
+    public async Task<Option<Channel>> GetByNumber(string number)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Channels
+            .Include(c => c.FFmpegProfile)
+            .ThenInclude(p => p.Resolution)
+            .Include(c => c.Artwork)
+            .Include(c => c.Watermark)
+            .OrderBy(c => c.Number)
+            .SingleOrDefaultAsync(c => c.Number == number)
+            .Map(Optional);
+    }
+
+    public async Task<List<Channel>> GetAll()
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Channels
+            .Include(c => c.FFmpegProfile)
+            .Include(c => c.Artwork)
+            .Include(c => c.Playouts)
+            .ToListAsync();
+    }
+
+    public async Task<List<Channel>> GetAllForGuide()
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Channels
+            .Include(c => c.Artwork)
+            .Include(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .Include(c => c.Playouts)
+            .ThenInclude(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(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(em => em.Genres)
+            .Include(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Genres)
+            .Include(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .ThenInclude(am => am.Genres)
+            .Include(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(c => c.Playouts)
+            .ThenInclude(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .ToListAsync();
+    }
+
+    public async Task Delete(int channelId)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Channel channel = await dbContext.Channels.FindAsync(channelId);
+        dbContext.Channels.Remove(channel);
+        await dbContext.SaveChangesAsync();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/ConfigElementRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/ConfigElementRepository.cs
index 6b735c9cf..d7bfc4bf2 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/ConfigElementRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/ConfigElementRepository.cs
@@ -1,82 +1,76 @@
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class ConfigElementRepository : IConfigElementRepository
 {
-    public class ConfigElementRepository : IConfigElementRepository
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public ConfigElementRepository(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<Unit> Upsert<T>(ConfigElementKey configElementKey, T value)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
 
-        public ConfigElementRepository(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        Option<ConfigElement> maybeElement = await dbContext.ConfigElements
+            .SelectOneAsync(c => c.Key, c => c.Key == configElementKey.Key);
 
-        public async Task<Unit> Upsert<T>(ConfigElementKey configElementKey, T value)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            Option<ConfigElement> maybeElement = await dbContext.ConfigElements
-                .SelectOneAsync(c => c.Key, c => c.Key == configElementKey.Key);
-
-            await maybeElement.Match(
-                async element =>
-                {
-                    element.Value = value.ToString();
-                    await dbContext.SaveChangesAsync();
-                },
-                async () =>
-                {
-                    var configElement = new ConfigElement
-                    {
-                        Key = configElementKey.Key,
-                        Value = value.ToString()
-                    };
-
-                    await dbContext.ConfigElements.AddAsync(configElement);
-                    await dbContext.SaveChangesAsync();
-                });
-
-            return Unit.Default;
-        }
-
-        public async Task<Option<ConfigElement>> Get(ConfigElementKey key)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.ConfigElements
-                .OrderBy(ce => ce.Key)
-                .SingleOrDefaultAsync(ce => ce.Key == key.Key)
-                .Map(Optional);
-        }
-
-        public Task<Option<T>> GetValue<T>(ConfigElementKey key) =>
-            Get(key).MapT(ce => (T) Convert.ChangeType(ce.Value, typeof(T)));
-
-        public async Task Delete(ConfigElement configElement)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            dbContext.ConfigElements.Remove(configElement);
-            await dbContext.SaveChangesAsync();
-        }
-
-        public async Task<Unit> Delete(ConfigElementKey configElementKey)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<ConfigElement> maybeExisting = await dbContext.ConfigElements
-                .SelectOneAsync(ce => ce.Key, ce => ce.Key == configElementKey.Key);
-            foreach (ConfigElement element in maybeExisting)
+        await maybeElement.Match(
+            async element =>
             {
-                dbContext.ConfigElements.Remove(element);
-            }
+                element.Value = value.ToString();
+                await dbContext.SaveChangesAsync();
+            },
+            async () =>
+            {
+                var configElement = new ConfigElement
+                {
+                    Key = configElementKey.Key,
+                    Value = value.ToString()
+                };
 
-            await dbContext.SaveChangesAsync();
+                await dbContext.ConfigElements.AddAsync(configElement);
+                await dbContext.SaveChangesAsync();
+            });
 
-            return Unit.Default;
-        }
+        return Unit.Default;
     }
-}
+
+    public async Task<Option<ConfigElement>> Get(ConfigElementKey key)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.ConfigElements
+            .OrderBy(ce => ce.Key)
+            .SingleOrDefaultAsync(ce => ce.Key == key.Key)
+            .Map(Optional);
+    }
+
+    public Task<Option<T>> GetValue<T>(ConfigElementKey key) =>
+        Get(key).MapT(ce => (T) Convert.ChangeType(ce.Value, typeof(T)));
+
+    public async Task Delete(ConfigElement configElement)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        dbContext.ConfigElements.Remove(configElement);
+        await dbContext.SaveChangesAsync();
+    }
+
+    public async Task<Unit> Delete(ConfigElementKey configElementKey)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<ConfigElement> maybeExisting = await dbContext.ConfigElements
+            .SelectOneAsync(ce => ce.Key, ce => ce.Key == configElementKey.Key);
+        foreach (ConfigElement element in maybeExisting)
+        {
+            dbContext.ConfigElements.Remove(element);
+        }
+
+        await dbContext.SaveChangesAsync();
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/EmbyTelevisionRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/EmbyTelevisionRepository.cs
index acf1d9b20..dd0a9dd00 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/EmbyTelevisionRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/EmbyTelevisionRepository.cs
@@ -1,623 +1,617 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class EmbyTelevisionRepository : IEmbyTelevisionRepository
 {
-    public class EmbyTelevisionRepository : IEmbyTelevisionRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public EmbyTelevisionRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbConnection = dbConnection;
+        _dbContextFactory = dbContextFactory;
+    }
 
-        public EmbyTelevisionRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _dbConnection = dbConnection;
-            _dbContextFactory = dbContextFactory;
-        }
-
-        public Task<List<EmbyItemEtag>> GetExistingShows(EmbyLibrary library) =>
-            _dbConnection.QueryAsync<EmbyItemEtag>(
-                    @"SELECT ItemId, Etag FROM EmbyShow
+    public Task<List<EmbyItemEtag>> GetExistingShows(EmbyLibrary library) =>
+        _dbConnection.QueryAsync<EmbyItemEtag>(
+                @"SELECT ItemId, Etag FROM EmbyShow
                       INNER JOIN Show S on EmbyShow.Id = S.Id
                       INNER JOIN MediaItem MI on S.Id = MI.Id
                       INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                       WHERE LP.LibraryId = @LibraryId",
-                    new { LibraryId = library.Id })
-                .Map(result => result.ToList());
+                new { LibraryId = library.Id })
+            .Map(result => result.ToList());
 
-        public Task<List<EmbyItemEtag>> GetExistingSeasons(EmbyLibrary library, string showItemId) =>
-            _dbConnection.QueryAsync<EmbyItemEtag>(
-                    @"SELECT EmbySeason.ItemId, EmbySeason.Etag FROM EmbySeason
+    public Task<List<EmbyItemEtag>> GetExistingSeasons(EmbyLibrary library, string showItemId) =>
+        _dbConnection.QueryAsync<EmbyItemEtag>(
+                @"SELECT EmbySeason.ItemId, EmbySeason.Etag FROM EmbySeason
                       INNER JOIN Season S on EmbySeason.Id = S.Id
                       INNER JOIN MediaItem MI on S.Id = MI.Id
                       INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                       INNER JOIN Show S2 on S.ShowId = S2.Id
                       INNER JOIN EmbyShow JS on S2.Id = JS.Id
                       WHERE LP.LibraryId = @LibraryId AND JS.ItemId = @ShowItemId",
-                    new { LibraryId = library.Id, ShowItemId = showItemId })
-                .Map(result => result.ToList());
+                new { LibraryId = library.Id, ShowItemId = showItemId })
+            .Map(result => result.ToList());
 
-        public Task<List<EmbyItemEtag>> GetExistingEpisodes(EmbyLibrary library, string seasonItemId) =>
-            _dbConnection.QueryAsync<EmbyItemEtag>(
-                    @"SELECT EmbyEpisode.ItemId, EmbyEpisode.Etag FROM EmbyEpisode
+    public Task<List<EmbyItemEtag>> GetExistingEpisodes(EmbyLibrary library, string seasonItemId) =>
+        _dbConnection.QueryAsync<EmbyItemEtag>(
+                @"SELECT EmbyEpisode.ItemId, EmbyEpisode.Etag FROM EmbyEpisode
                       INNER JOIN Episode E on EmbyEpisode.Id = E.Id
                       INNER JOIN MediaItem MI on E.Id = MI.Id
                       INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                       INNER JOIN Season S2 on E.SeasonId = S2.Id
                       INNER JOIN EmbySeason JS on S2.Id = JS.Id
                       WHERE LP.LibraryId = @LibraryId AND JS.ItemId = @SeasonItemId",
-                    new { LibraryId = library.Id, SeasonItemId = seasonItemId })
-                .Map(result => result.ToList());
+                new { LibraryId = library.Id, SeasonItemId = seasonItemId })
+            .Map(result => result.ToList());
 
-        public async Task<bool> AddShow(EmbyShow show)
+    public async Task<bool> AddShow(EmbyShow show)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await dbContext.AddAsync(show);
+        if (await dbContext.SaveChangesAsync() <= 0)
         {
+            return false;
+        }
+
+        await dbContext.Entry(show).Reference(m => m.LibraryPath).LoadAsync();
+        await dbContext.Entry(show.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+        return true;
+    }
+
+    public async Task<Option<EmbyShow>> Update(EmbyShow show)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<EmbyShow> maybeExisting = await dbContext.EmbyShows
+            .Include(m => m.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(m => m.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .Filter(m => m.ItemId == show.ItemId)
+            .OrderBy(m => m.ItemId)
+            .SingleOrDefaultAsync();
+
+        if (maybeExisting.IsSome)
+        {
+            EmbyShow existing = maybeExisting.ValueUnsafe();
+
+            // library path is used for search indexing later
+            show.LibraryPath = existing.LibraryPath;
+            show.Id = existing.Id;
+
+            existing.Etag = show.Etag;
+
+            // metadata
+            ShowMetadata metadata = existing.ShowMetadata.Head();
+            ShowMetadata incomingMetadata = show.ShowMetadata.Head();
+            metadata.MetadataKind = incomingMetadata.MetadataKind;
+            metadata.ContentRating = incomingMetadata.ContentRating;
+            metadata.Title = incomingMetadata.Title;
+            metadata.SortTitle = incomingMetadata.SortTitle;
+            metadata.Plot = incomingMetadata.Plot;
+            metadata.Year = incomingMetadata.Year;
+            metadata.Tagline = incomingMetadata.Tagline;
+            metadata.DateAdded = incomingMetadata.DateAdded;
+            metadata.DateUpdated = DateTime.UtcNow;
+
+            // genres
+            foreach (Genre genre in metadata.Genres
+                         .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Genres.Remove(genre);
+            }
+
+            foreach (Genre genre in incomingMetadata.Genres
+                         .Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Genres.Add(genre);
+            }
+
+            // tags
+            foreach (Tag tag in metadata.Tags
+                         .Filter(g => incomingMetadata.Tags.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Tags.Remove(tag);
+            }
+
+            foreach (Tag tag in incomingMetadata.Tags
+                         .Filter(g => metadata.Tags.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Tags.Add(tag);
+            }
+
+            // studios
+            foreach (Studio studio in metadata.Studios
+                         .Filter(g => incomingMetadata.Studios.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Studios.Remove(studio);
+            }
+
+            foreach (Studio studio in incomingMetadata.Studios
+                         .Filter(g => metadata.Studios.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Studios.Add(studio);
+            }
+
+            // actors
+            foreach (Actor actor in metadata.Actors
+                         .Filter(
+                             a => incomingMetadata.Actors.All(
+                                 a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
+                         .ToList())
+            {
+                metadata.Actors.Remove(actor);
+            }
+
+            foreach (Actor actor in incomingMetadata.Actors
+                         .Filter(a => metadata.Actors.All(a2 => a2.Name != a.Name))
+                         .ToList())
+            {
+                metadata.Actors.Add(actor);
+            }
+
+            // guids
+            foreach (MetadataGuid guid in metadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Remove(guid);
+            }
+
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Add(guid);
+            }
+
+            metadata.ReleaseDate = incomingMetadata.ReleaseDate;
+
+            // poster
+            Artwork incomingPoster =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+            if (incomingPoster != null)
+            {
+                Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+                if (poster == null)
+                {
+                    poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
+                    metadata.Artwork.Add(poster);
+                }
+
+                poster.Path = incomingPoster.Path;
+                poster.DateAdded = incomingPoster.DateAdded;
+                poster.DateUpdated = incomingPoster.DateUpdated;
+            }
+
+            // fan art
+            Artwork incomingFanArt =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+            if (incomingFanArt != null)
+            {
+                Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+                if (fanArt == null)
+                {
+                    fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
+                    metadata.Artwork.Add(fanArt);
+                }
+
+                fanArt.Path = incomingFanArt.Path;
+                fanArt.DateAdded = incomingFanArt.DateAdded;
+                fanArt.DateUpdated = incomingFanArt.DateUpdated;
+            }
+
+            var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
+            foreach (Artwork artworkToRemove in metadata.Artwork
+                         .Filter(a => !paths.Contains(a.Path))
+                         .ToList())
+            {
+                metadata.Artwork.Remove(artworkToRemove);
+            }
+        }
+
+        await dbContext.SaveChangesAsync();
+
+        return maybeExisting;
+    }
+
+    public async Task<bool> AddSeason(EmbyShow show, EmbySeason season)
+    {
+        try
+        {
+            season.ShowId = await _dbConnection.ExecuteScalarAsync<int>(
+                @"SELECT Id FROM EmbyShow WHERE ItemId = @ItemId",
+                new { show.ItemId });
+
             await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            await dbContext.AddAsync(show);
+            await dbContext.AddAsync(season);
             if (await dbContext.SaveChangesAsync() <= 0)
             {
                 return false;
             }
 
-            await dbContext.Entry(show).Reference(m => m.LibraryPath).LoadAsync();
-            await dbContext.Entry(show.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            await dbContext.Entry(season).Reference(m => m.LibraryPath).LoadAsync();
+            await dbContext.Entry(season.LibraryPath).Reference(lp => lp.Library).LoadAsync();
             return true;
         }
-
-        public async Task<Option<EmbyShow>> Update(EmbyShow show)
+        catch (Exception)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<EmbyShow> maybeExisting = await dbContext.EmbyShows
-                .Include(m => m.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(m => m.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .Filter(m => m.ItemId == show.ItemId)
-                .OrderBy(m => m.ItemId)
-                .SingleOrDefaultAsync();
+            return false;
+        }
+    }
 
-            if (maybeExisting.IsSome)
+    public async Task<Option<EmbySeason>> Update(EmbySeason season)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<EmbySeason> maybeExisting = await dbContext.EmbySeasons
+            .Include(m => m.LibraryPath)
+            .Include(m => m.SeasonMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(m => m.SeasonMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Filter(m => m.ItemId == season.ItemId)
+            .OrderBy(m => m.ItemId)
+            .SingleOrDefaultAsync();
+
+        if (maybeExisting.IsSome)
+        {
+            EmbySeason existing = maybeExisting.ValueUnsafe();
+
+            // library path is used for search indexing later
+            season.LibraryPath = existing.LibraryPath;
+            season.Id = existing.Id;
+
+            existing.Etag = season.Etag;
+            existing.SeasonNumber = season.SeasonNumber;
+
+            // metadata
+            SeasonMetadata metadata = existing.SeasonMetadata.Head();
+            SeasonMetadata incomingMetadata = season.SeasonMetadata.Head();
+            metadata.Title = incomingMetadata.Title;
+            metadata.SortTitle = incomingMetadata.SortTitle;
+            metadata.Year = incomingMetadata.Year;
+            metadata.DateAdded = incomingMetadata.DateAdded;
+            metadata.DateUpdated = DateTime.UtcNow;
+            metadata.ReleaseDate = incomingMetadata.ReleaseDate;
+
+            // poster
+            Artwork incomingPoster =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+            if (incomingPoster != null)
             {
-                EmbyShow existing = maybeExisting.ValueUnsafe();
-
-                // library path is used for search indexing later
-                show.LibraryPath = existing.LibraryPath;
-                show.Id = existing.Id;
-
-                existing.Etag = show.Etag;
-
-                // metadata
-                ShowMetadata metadata = existing.ShowMetadata.Head();
-                ShowMetadata incomingMetadata = show.ShowMetadata.Head();
-                metadata.MetadataKind = incomingMetadata.MetadataKind;
-                metadata.ContentRating = incomingMetadata.ContentRating;
-                metadata.Title = incomingMetadata.Title;
-                metadata.SortTitle = incomingMetadata.SortTitle;
-                metadata.Plot = incomingMetadata.Plot;
-                metadata.Year = incomingMetadata.Year;
-                metadata.Tagline = incomingMetadata.Tagline;
-                metadata.DateAdded = incomingMetadata.DateAdded;
-                metadata.DateUpdated = DateTime.UtcNow;
-
-                // genres
-                foreach (Genre genre in metadata.Genres
-                    .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
+                Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+                if (poster == null)
                 {
-                    metadata.Genres.Remove(genre);
+                    poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
+                    metadata.Artwork.Add(poster);
                 }
 
-                foreach (Genre genre in incomingMetadata.Genres
-                    .Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Genres.Add(genre);
-                }
-
-                // tags
-                foreach (Tag tag in metadata.Tags
-                    .Filter(g => incomingMetadata.Tags.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Tags.Remove(tag);
-                }
-
-                foreach (Tag tag in incomingMetadata.Tags
-                    .Filter(g => metadata.Tags.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Tags.Add(tag);
-                }
-
-                // studios
-                foreach (Studio studio in metadata.Studios
-                    .Filter(g => incomingMetadata.Studios.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Studios.Remove(studio);
-                }
-
-                foreach (Studio studio in incomingMetadata.Studios
-                    .Filter(g => metadata.Studios.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Studios.Add(studio);
-                }
-
-                // actors
-                foreach (Actor actor in metadata.Actors
-                    .Filter(
-                        a => incomingMetadata.Actors.All(
-                            a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
-                    .ToList())
-                {
-                    metadata.Actors.Remove(actor);
-                }
-
-                foreach (Actor actor in incomingMetadata.Actors
-                    .Filter(a => metadata.Actors.All(a2 => a2.Name != a.Name))
-                    .ToList())
-                {
-                    metadata.Actors.Add(actor);
-                }
-
-                // guids
-                foreach (MetadataGuid guid in metadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Remove(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Add(guid);
-                }
-
-                metadata.ReleaseDate = incomingMetadata.ReleaseDate;
-
-                // poster
-                Artwork incomingPoster =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                if (incomingPoster != null)
-                {
-                    Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                    if (poster == null)
-                    {
-                        poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
-                        metadata.Artwork.Add(poster);
-                    }
-
-                    poster.Path = incomingPoster.Path;
-                    poster.DateAdded = incomingPoster.DateAdded;
-                    poster.DateUpdated = incomingPoster.DateUpdated;
-                }
-
-                // fan art
-                Artwork incomingFanArt =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                if (incomingFanArt != null)
-                {
-                    Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                    if (fanArt == null)
-                    {
-                        fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
-                        metadata.Artwork.Add(fanArt);
-                    }
-
-                    fanArt.Path = incomingFanArt.Path;
-                    fanArt.DateAdded = incomingFanArt.DateAdded;
-                    fanArt.DateUpdated = incomingFanArt.DateUpdated;
-                }
-
-                var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
-                foreach (Artwork artworkToRemove in metadata.Artwork
-                    .Filter(a => !paths.Contains(a.Path))
-                    .ToList())
-                {
-                    metadata.Artwork.Remove(artworkToRemove);
-                }
+                poster.Path = incomingPoster.Path;
+                poster.DateAdded = incomingPoster.DateAdded;
+                poster.DateUpdated = incomingPoster.DateUpdated;
             }
 
-            await dbContext.SaveChangesAsync();
+            // thumbnail
+            Artwork incomingThumbnail =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
+            if (incomingThumbnail != null)
+            {
+                Artwork thumb = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
+                if (thumb == null)
+                {
+                    thumb = new Artwork { ArtworkKind = ArtworkKind.Thumbnail };
+                    metadata.Artwork.Add(thumb);
+                }
 
-            return maybeExisting;
+                thumb.Path = incomingThumbnail.Path;
+                thumb.DateAdded = incomingThumbnail.DateAdded;
+                thumb.DateUpdated = incomingThumbnail.DateUpdated;
+            }
+
+            // fan art
+            Artwork incomingFanArt =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+            if (incomingFanArt != null)
+            {
+                Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+                if (fanArt == null)
+                {
+                    fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
+                    metadata.Artwork.Add(fanArt);
+                }
+
+                fanArt.Path = incomingFanArt.Path;
+                fanArt.DateAdded = incomingFanArt.DateAdded;
+                fanArt.DateUpdated = incomingFanArt.DateUpdated;
+            }
+
+            // guids
+            foreach (MetadataGuid guid in metadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Remove(guid);
+            }
+
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Add(guid);
+            }
+
+            var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
+            foreach (Artwork artworkToRemove in metadata.Artwork
+                         .Filter(a => !paths.Contains(a.Path))
+                         .ToList())
+            {
+                metadata.Artwork.Remove(artworkToRemove);
+            }
         }
 
-        public async Task<bool> AddSeason(EmbyShow show, EmbySeason season)
+        await dbContext.SaveChangesAsync();
+
+        return maybeExisting;
+    }
+
+    public async Task<bool> AddEpisode(EmbySeason season, EmbyEpisode episode)
+    {
+        try
         {
-            try
-            {
-                season.ShowId = await _dbConnection.ExecuteScalarAsync<int>(
-                    @"SELECT Id FROM EmbyShow WHERE ItemId = @ItemId",
-                    new { show.ItemId });
+            episode.SeasonId = await _dbConnection.ExecuteScalarAsync<int>(
+                @"SELECT Id FROM EmbySeason WHERE ItemId = @ItemId",
+                new { season.ItemId });
 
-                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-                await dbContext.AddAsync(season);
-                if (await dbContext.SaveChangesAsync() <= 0)
-                {
-                    return false;
-                }
-
-                await dbContext.Entry(season).Reference(m => m.LibraryPath).LoadAsync();
-                await dbContext.Entry(season.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return true;
-            }
-            catch (Exception)
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await dbContext.AddAsync(episode);
+            if (await dbContext.SaveChangesAsync() <= 0)
             {
                 return false;
             }
+
+            await dbContext.Entry(episode).Reference(m => m.LibraryPath).LoadAsync();
+            await dbContext.Entry(episode.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            await dbContext.Entry(episode).Reference(e => e.Season).LoadAsync();
+            return true;
         }
-
-        public async Task<Option<EmbySeason>> Update(EmbySeason season)
+        catch (Exception)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<EmbySeason> maybeExisting = await dbContext.EmbySeasons
-                .Include(m => m.LibraryPath)
-                .Include(m => m.SeasonMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => m.SeasonMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Filter(m => m.ItemId == season.ItemId)
-                .OrderBy(m => m.ItemId)
-                .SingleOrDefaultAsync();
+            return false;
+        }
+    }
 
-            if (maybeExisting.IsSome)
+    public async Task<Option<EmbyEpisode>> Update(EmbyEpisode episode)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<EmbyEpisode> maybeExisting = await dbContext.EmbyEpisodes
+            .Include(m => m.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(m => m.Season)
+            .Include(m => m.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .Filter(m => m.ItemId == episode.ItemId)
+            .OrderBy(m => m.ItemId)
+            .SingleOrDefaultAsync();
+
+        if (maybeExisting.IsSome)
+        {
+            EmbyEpisode existing = maybeExisting.ValueUnsafe();
+
+            // library path is used for search indexing later
+            episode.LibraryPath = existing.LibraryPath;
+            episode.Id = existing.Id;
+
+            existing.Etag = episode.Etag;
+
+            // metadata
+            // TODO: multiple metadata?
+            EpisodeMetadata metadata = existing.EpisodeMetadata.Head();
+            EpisodeMetadata incomingMetadata = episode.EpisodeMetadata.Head();
+            metadata.Title = incomingMetadata.Title;
+            metadata.SortTitle = incomingMetadata.SortTitle;
+            metadata.Plot = incomingMetadata.Plot;
+            metadata.Year = incomingMetadata.Year;
+            metadata.DateAdded = incomingMetadata.DateAdded;
+            metadata.DateUpdated = DateTime.UtcNow;
+            metadata.ReleaseDate = incomingMetadata.ReleaseDate;
+            metadata.EpisodeNumber = incomingMetadata.EpisodeNumber;
+
+            // thumbnail
+            Artwork incomingThumbnail =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
+            if (incomingThumbnail != null)
             {
-                EmbySeason existing = maybeExisting.ValueUnsafe();
-
-                // library path is used for search indexing later
-                season.LibraryPath = existing.LibraryPath;
-                season.Id = existing.Id;
-
-                existing.Etag = season.Etag;
-                existing.SeasonNumber = season.SeasonNumber;
-
-                // metadata
-                SeasonMetadata metadata = existing.SeasonMetadata.Head();
-                SeasonMetadata incomingMetadata = season.SeasonMetadata.Head();
-                metadata.Title = incomingMetadata.Title;
-                metadata.SortTitle = incomingMetadata.SortTitle;
-                metadata.Year = incomingMetadata.Year;
-                metadata.DateAdded = incomingMetadata.DateAdded;
-                metadata.DateUpdated = DateTime.UtcNow;
-                metadata.ReleaseDate = incomingMetadata.ReleaseDate;
-
-                // poster
-                Artwork incomingPoster =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                if (incomingPoster != null)
+                Artwork thumbnail = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
+                if (thumbnail == null)
                 {
-                    Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                    if (poster == null)
-                    {
-                        poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
-                        metadata.Artwork.Add(poster);
-                    }
-
-                    poster.Path = incomingPoster.Path;
-                    poster.DateAdded = incomingPoster.DateAdded;
-                    poster.DateUpdated = incomingPoster.DateUpdated;
+                    thumbnail = new Artwork { ArtworkKind = ArtworkKind.Thumbnail };
+                    metadata.Artwork.Add(thumbnail);
                 }
 
-                // thumbnail
-                Artwork incomingThumbnail =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
-                if (incomingThumbnail != null)
-                {
-                    Artwork thumb = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
-                    if (thumb == null)
-                    {
-                        thumb = new Artwork { ArtworkKind = ArtworkKind.Thumbnail };
-                        metadata.Artwork.Add(thumb);
-                    }
-
-                    thumb.Path = incomingThumbnail.Path;
-                    thumb.DateAdded = incomingThumbnail.DateAdded;
-                    thumb.DateUpdated = incomingThumbnail.DateUpdated;
-                }
-
-                // fan art
-                Artwork incomingFanArt =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                if (incomingFanArt != null)
-                {
-                    Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                    if (fanArt == null)
-                    {
-                        fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
-                        metadata.Artwork.Add(fanArt);
-                    }
-
-                    fanArt.Path = incomingFanArt.Path;
-                    fanArt.DateAdded = incomingFanArt.DateAdded;
-                    fanArt.DateUpdated = incomingFanArt.DateUpdated;
-                }
-
-                // guids
-                foreach (MetadataGuid guid in metadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Remove(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Add(guid);
-                }
-
-                var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
-                foreach (Artwork artworkToRemove in metadata.Artwork
-                    .Filter(a => !paths.Contains(a.Path))
-                    .ToList())
-                {
-                    metadata.Artwork.Remove(artworkToRemove);
-                }
+                thumbnail.Path = incomingThumbnail.Path;
+                thumbnail.DateAdded = incomingThumbnail.DateAdded;
+                thumbnail.DateUpdated = incomingThumbnail.DateUpdated;
             }
 
-            await dbContext.SaveChangesAsync();
-
-            return maybeExisting;
-        }
-
-        public async Task<bool> AddEpisode(EmbySeason season, EmbyEpisode episode)
-        {
-            try
+            // directors
+            foreach (Director director in metadata.Directors
+                         .Filter(d => incomingMetadata.Directors.All(d2 => d2.Name != d.Name))
+                         .ToList())
             {
-                episode.SeasonId = await _dbConnection.ExecuteScalarAsync<int>(
-                    @"SELECT Id FROM EmbySeason WHERE ItemId = @ItemId",
-                    new { season.ItemId });
-
-                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-                await dbContext.AddAsync(episode);
-                if (await dbContext.SaveChangesAsync() <= 0)
-                {
-                    return false;
-                }
-
-                await dbContext.Entry(episode).Reference(m => m.LibraryPath).LoadAsync();
-                await dbContext.Entry(episode.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                await dbContext.Entry(episode).Reference(e => e.Season).LoadAsync();
-                return true;
-            }
-            catch (Exception)
-            {
-                return false;
-            }
-        }
-
-        public async Task<Option<EmbyEpisode>> Update(EmbyEpisode episode)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<EmbyEpisode> maybeExisting = await dbContext.EmbyEpisodes
-                .Include(m => m.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(m => m.Season)
-                .Include(m => m.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .Filter(m => m.ItemId == episode.ItemId)
-                .OrderBy(m => m.ItemId)
-                .SingleOrDefaultAsync();
-
-            if (maybeExisting.IsSome)
-            {
-                EmbyEpisode existing = maybeExisting.ValueUnsafe();
-
-                // library path is used for search indexing later
-                episode.LibraryPath = existing.LibraryPath;
-                episode.Id = existing.Id;
-
-                existing.Etag = episode.Etag;
-
-                // metadata
-                // TODO: multiple metadata?
-                EpisodeMetadata metadata = existing.EpisodeMetadata.Head();
-                EpisodeMetadata incomingMetadata = episode.EpisodeMetadata.Head();
-                metadata.Title = incomingMetadata.Title;
-                metadata.SortTitle = incomingMetadata.SortTitle;
-                metadata.Plot = incomingMetadata.Plot;
-                metadata.Year = incomingMetadata.Year;
-                metadata.DateAdded = incomingMetadata.DateAdded;
-                metadata.DateUpdated = DateTime.UtcNow;
-                metadata.ReleaseDate = incomingMetadata.ReleaseDate;
-                metadata.EpisodeNumber = incomingMetadata.EpisodeNumber;
-
-                // thumbnail
-                Artwork incomingThumbnail =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
-                if (incomingThumbnail != null)
-                {
-                    Artwork thumbnail = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
-                    if (thumbnail == null)
-                    {
-                        thumbnail = new Artwork { ArtworkKind = ArtworkKind.Thumbnail };
-                        metadata.Artwork.Add(thumbnail);
-                    }
-
-                    thumbnail.Path = incomingThumbnail.Path;
-                    thumbnail.DateAdded = incomingThumbnail.DateAdded;
-                    thumbnail.DateUpdated = incomingThumbnail.DateUpdated;
-                }
-
-                // directors
-                foreach (Director director in metadata.Directors
-                    .Filter(d => incomingMetadata.Directors.All(d2 => d2.Name != d.Name))
-                    .ToList())
-                {
-                    metadata.Directors.Remove(director);
-                }
-
-                foreach (Director director in incomingMetadata.Directors
-                    .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name))
-                    .ToList())
-                {
-                    metadata.Directors.Add(director);
-                }
-
-                // writers
-                foreach (Writer writer in metadata.Writers
-                    .Filter(w => incomingMetadata.Writers.All(w2 => w2.Name != w.Name))
-                    .ToList())
-                {
-                    metadata.Writers.Remove(writer);
-                }
-
-                foreach (Writer writer in incomingMetadata.Writers
-                    .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name))
-                    .ToList())
-                {
-                    metadata.Writers.Add(writer);
-                }
-
-                // guids
-                foreach (MetadataGuid guid in metadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Remove(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Add(guid);
-                }
-
-                var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
-                foreach (Artwork artworkToRemove in metadata.Artwork
-                    .Filter(a => !paths.Contains(a.Path))
-                    .ToList())
-                {
-                    metadata.Artwork.Remove(artworkToRemove);
-                }
-
-                // version
-                MediaVersion version = existing.MediaVersions.Head();
-                MediaVersion incomingVersion = episode.MediaVersions.Head();
-                version.Name = incomingVersion.Name;
-                version.DateAdded = incomingVersion.DateAdded;
-
-                // media file
-                MediaFile file = version.MediaFiles.Head();
-                MediaFile incomingFile = incomingVersion.MediaFiles.Head();
-                file.Path = incomingFile.Path;
+                metadata.Directors.Remove(director);
             }
 
-            await dbContext.SaveChangesAsync();
+            foreach (Director director in incomingMetadata.Directors
+                         .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name))
+                         .ToList())
+            {
+                metadata.Directors.Add(director);
+            }
 
-            return maybeExisting;
+            // writers
+            foreach (Writer writer in metadata.Writers
+                         .Filter(w => incomingMetadata.Writers.All(w2 => w2.Name != w.Name))
+                         .ToList())
+            {
+                metadata.Writers.Remove(writer);
+            }
+
+            foreach (Writer writer in incomingMetadata.Writers
+                         .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name))
+                         .ToList())
+            {
+                metadata.Writers.Add(writer);
+            }
+
+            // guids
+            foreach (MetadataGuid guid in metadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Remove(guid);
+            }
+
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Add(guid);
+            }
+
+            var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
+            foreach (Artwork artworkToRemove in metadata.Artwork
+                         .Filter(a => !paths.Contains(a.Path))
+                         .ToList())
+            {
+                metadata.Artwork.Remove(artworkToRemove);
+            }
+
+            // version
+            MediaVersion version = existing.MediaVersions.Head();
+            MediaVersion incomingVersion = episode.MediaVersions.Head();
+            version.Name = incomingVersion.Name;
+            version.DateAdded = incomingVersion.DateAdded;
+
+            // media file
+            MediaFile file = version.MediaFiles.Head();
+            MediaFile incomingFile = incomingVersion.MediaFiles.Head();
+            file.Path = incomingFile.Path;
         }
 
-        public async Task<List<int>> RemoveMissingShows(EmbyLibrary library, List<string> showIds)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        await dbContext.SaveChangesAsync();
+
+        return maybeExisting;
+    }
+
+    public async Task<List<int>> RemoveMissingShows(EmbyLibrary library, List<string> showIds)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbyShow js ON js.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 WHERE lp.LibraryId = @LibraryId AND js.ItemId IN @ShowIds",
-                new { LibraryId = library.Id, ShowIds = showIds }).Map(result => result.ToList());
+            new { LibraryId = library.Id, ShowIds = showIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
-        }
+        return ids;
+    }
 
-        public Task<Unit> RemoveMissingSeasons(EmbyLibrary library, List<string> seasonIds) =>
-            _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+    public Task<Unit> RemoveMissingSeasons(EmbyLibrary library, List<string> seasonIds) =>
+        _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbySeason js ON js.Id = m.Id
                 INNER JOIN LibraryPath LP on m.LibraryPathId = LP.Id
                 WHERE LP.LibraryId = @LibraryId AND js.ItemId IN @SeasonIds)",
-                new { LibraryId = library.Id, SeasonIds = seasonIds }).ToUnit();
+            new { LibraryId = library.Id, SeasonIds = seasonIds }).ToUnit();
 
-        public async Task<List<int>> RemoveMissingEpisodes(EmbyLibrary library, List<string> episodeIds)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+    public async Task<List<int>> RemoveMissingEpisodes(EmbyLibrary library, List<string> episodeIds)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbyEpisode ee ON ee.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 WHERE lp.LibraryId = @LibraryId AND ee.ItemId IN @EpisodeIds",
-                new { LibraryId = library.Id, EpisodeIds = episodeIds }).Map(result => result.ToList());
+            new { LibraryId = library.Id, EpisodeIds = episodeIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
-        }
-
-        public async Task<Unit> DeleteEmptySeasons(EmbyLibrary library)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<EmbySeason> seasons = await dbContext.EmbySeasons
-                .Filter(s => s.LibraryPath.LibraryId == library.Id)
-                .Filter(s => s.Episodes.Count == 0)
-                .ToListAsync();
-            dbContext.Seasons.RemoveRange(seasons);
-            await dbContext.SaveChangesAsync();
-            return Unit.Default;
-        }
-
-        public async Task<List<int>> DeleteEmptyShows(EmbyLibrary library)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<EmbyShow> shows = await dbContext.EmbyShows
-                .Filter(s => s.LibraryPath.LibraryId == library.Id)
-                .Filter(s => s.Seasons.Count == 0)
-                .ToListAsync();
-            var ids = shows.Map(s => s.Id).ToList();
-            dbContext.Shows.RemoveRange(shows);
-            await dbContext.SaveChangesAsync();
-            return ids;
-        }
+        return ids;
     }
-}
+
+    public async Task<Unit> DeleteEmptySeasons(EmbyLibrary library)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<EmbySeason> seasons = await dbContext.EmbySeasons
+            .Filter(s => s.LibraryPath.LibraryId == library.Id)
+            .Filter(s => s.Episodes.Count == 0)
+            .ToListAsync();
+        dbContext.Seasons.RemoveRange(seasons);
+        await dbContext.SaveChangesAsync();
+        return Unit.Default;
+    }
+
+    public async Task<List<int>> DeleteEmptyShows(EmbyLibrary library)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<EmbyShow> shows = await dbContext.EmbyShows
+            .Filter(s => s.LibraryPath.LibraryId == library.Id)
+            .Filter(s => s.Seasons.Count == 0)
+            .ToListAsync();
+        var ids = shows.Map(s => s.Id).ToList();
+        dbContext.Shows.RemoveRange(shows);
+        await dbContext.SaveChangesAsync();
+        return ids;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/FFmpegProfileRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/FFmpegProfileRepository.cs
index 1bedf0eab..2951c38d4 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/FFmpegProfileRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/FFmpegProfileRepository.cs
@@ -1,35 +1,33 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.ChangeTracking;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class FFmpegProfileRepository : IFFmpegProfileRepository
 {
-    public class FFmpegProfileRepository : IFFmpegProfileRepository
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public FFmpegProfileRepository(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    public async Task<FFmpegProfile> Copy(int ffmpegProfileId, string name)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        FFmpegProfile ffmpegProfile = await dbContext.FFmpegProfiles.FindAsync(ffmpegProfileId);
 
-        public FFmpegProfileRepository(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        PropertyValues values = dbContext.Entry(ffmpegProfile).CurrentValues.Clone();
+        values["Id"] = 0;
 
-        public async Task<FFmpegProfile> Copy(int ffmpegProfileId, string name)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            FFmpegProfile ffmpegProfile = await dbContext.FFmpegProfiles.FindAsync(ffmpegProfileId);
+        var clone = new FFmpegProfile();
+        await dbContext.AddAsync(clone);
+        dbContext.Entry(clone).CurrentValues.SetValues(values);
+        clone.Name = name;
 
-            PropertyValues values = dbContext.Entry(ffmpegProfile).CurrentValues.Clone();
-            values["Id"] = 0;
+        await dbContext.SaveChangesAsync();
+        await dbContext.Entry(clone).Reference(f => f.Resolution).LoadAsync();
 
-            var clone = new FFmpegProfile();
-            await dbContext.AddAsync(clone);
-            dbContext.Entry(clone).CurrentValues.SetValues(values);
-            clone.Name = name;
-
-            await dbContext.SaveChangesAsync();
-            await dbContext.Entry(clone).Reference(f => f.Resolution).LoadAsync();
-
-            return clone;
-        }
+        return clone;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/JellyfinTelevisionRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/JellyfinTelevisionRepository.cs
index a01d24384..8ef0225f4 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/JellyfinTelevisionRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/JellyfinTelevisionRepository.cs
@@ -1,624 +1,618 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class JellyfinTelevisionRepository : IJellyfinTelevisionRepository
 {
-    public class JellyfinTelevisionRepository : IJellyfinTelevisionRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public JellyfinTelevisionRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbConnection = dbConnection;
+        _dbContextFactory = dbContextFactory;
+    }
 
-        public JellyfinTelevisionRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _dbConnection = dbConnection;
-            _dbContextFactory = dbContextFactory;
-        }
-
-        public Task<List<JellyfinItemEtag>> GetExistingShows(JellyfinLibrary library) =>
-            _dbConnection.QueryAsync<JellyfinItemEtag>(
-                    @"SELECT ItemId, Etag FROM JellyfinShow
+    public Task<List<JellyfinItemEtag>> GetExistingShows(JellyfinLibrary library) =>
+        _dbConnection.QueryAsync<JellyfinItemEtag>(
+                @"SELECT ItemId, Etag FROM JellyfinShow
                       INNER JOIN Show S on JellyfinShow.Id = S.Id
                       INNER JOIN MediaItem MI on S.Id = MI.Id
                       INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                       WHERE LP.LibraryId = @LibraryId",
-                    new { LibraryId = library.Id })
-                .Map(result => result.ToList());
+                new { LibraryId = library.Id })
+            .Map(result => result.ToList());
 
-        public Task<List<JellyfinItemEtag>> GetExistingSeasons(JellyfinLibrary library, string showItemId) =>
-            _dbConnection.QueryAsync<JellyfinItemEtag>(
-                    @"SELECT JellyfinSeason.ItemId, JellyfinSeason.Etag FROM JellyfinSeason
+    public Task<List<JellyfinItemEtag>> GetExistingSeasons(JellyfinLibrary library, string showItemId) =>
+        _dbConnection.QueryAsync<JellyfinItemEtag>(
+                @"SELECT JellyfinSeason.ItemId, JellyfinSeason.Etag FROM JellyfinSeason
                       INNER JOIN Season S on JellyfinSeason.Id = S.Id
                       INNER JOIN MediaItem MI on S.Id = MI.Id
                       INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                       INNER JOIN Show S2 on S.ShowId = S2.Id
                       INNER JOIN JellyfinShow JS on S2.Id = JS.Id
                       WHERE LP.LibraryId = @LibraryId AND JS.ItemId = @ShowItemId",
-                    new { LibraryId = library.Id, ShowItemId = showItemId })
-                .Map(result => result.ToList());
+                new { LibraryId = library.Id, ShowItemId = showItemId })
+            .Map(result => result.ToList());
 
-        public Task<List<JellyfinItemEtag>> GetExistingEpisodes(JellyfinLibrary library, string seasonItemId) =>
-            _dbConnection.QueryAsync<JellyfinItemEtag>(
-                    @"SELECT JellyfinEpisode.ItemId, JellyfinEpisode.Etag FROM JellyfinEpisode
+    public Task<List<JellyfinItemEtag>> GetExistingEpisodes(JellyfinLibrary library, string seasonItemId) =>
+        _dbConnection.QueryAsync<JellyfinItemEtag>(
+                @"SELECT JellyfinEpisode.ItemId, JellyfinEpisode.Etag FROM JellyfinEpisode
                       INNER JOIN Episode E on JellyfinEpisode.Id = E.Id
                       INNER JOIN MediaItem MI on E.Id = MI.Id
                       INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                       INNER JOIN Season S2 on E.SeasonId = S2.Id
                       INNER JOIN JellyfinSeason JS on S2.Id = JS.Id
                       WHERE LP.LibraryId = @LibraryId AND JS.ItemId = @SeasonItemId",
-                    new { LibraryId = library.Id, SeasonItemId = seasonItemId })
-                .Map(result => result.ToList());
+                new { LibraryId = library.Id, SeasonItemId = seasonItemId })
+            .Map(result => result.ToList());
 
-        public async Task<bool> AddShow(JellyfinShow show)
+    public async Task<bool> AddShow(JellyfinShow show)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await dbContext.AddAsync(show);
+        if (await dbContext.SaveChangesAsync() <= 0)
         {
+            return false;
+        }
+
+        await dbContext.Entry(show).Reference(m => m.LibraryPath).LoadAsync();
+        await dbContext.Entry(show.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+        return true;
+    }
+
+    public async Task<Option<JellyfinShow>> Update(JellyfinShow show)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<JellyfinShow> maybeExisting = await dbContext.JellyfinShows
+            .Include(m => m.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(m => m.ShowMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(m => m.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .Filter(m => m.ItemId == show.ItemId)
+            .OrderBy(m => m.ItemId)
+            .SingleOrDefaultAsync();
+
+        if (maybeExisting.IsSome)
+        {
+            JellyfinShow existing = maybeExisting.ValueUnsafe();
+
+            // library path is used for search indexing later
+            show.LibraryPath = existing.LibraryPath;
+            show.Id = existing.Id;
+
+            existing.Etag = show.Etag;
+
+            // metadata
+            ShowMetadata metadata = existing.ShowMetadata.Head();
+            ShowMetadata incomingMetadata = show.ShowMetadata.Head();
+            metadata.MetadataKind = incomingMetadata.MetadataKind;
+            metadata.ContentRating = incomingMetadata.ContentRating;
+            metadata.Title = incomingMetadata.Title;
+            metadata.SortTitle = incomingMetadata.SortTitle;
+            metadata.Plot = incomingMetadata.Plot;
+            metadata.Year = incomingMetadata.Year;
+            metadata.Tagline = incomingMetadata.Tagline;
+            metadata.DateAdded = incomingMetadata.DateAdded;
+            metadata.DateUpdated = DateTime.UtcNow;
+
+            // genres
+            foreach (Genre genre in metadata.Genres
+                         .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Genres.Remove(genre);
+            }
+
+            foreach (Genre genre in incomingMetadata.Genres
+                         .Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Genres.Add(genre);
+            }
+
+            // tags
+            foreach (Tag tag in metadata.Tags
+                         .Filter(g => incomingMetadata.Tags.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Tags.Remove(tag);
+            }
+
+            foreach (Tag tag in incomingMetadata.Tags
+                         .Filter(g => metadata.Tags.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Tags.Add(tag);
+            }
+
+            // studios
+            foreach (Studio studio in metadata.Studios
+                         .Filter(g => incomingMetadata.Studios.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Studios.Remove(studio);
+            }
+
+            foreach (Studio studio in incomingMetadata.Studios
+                         .Filter(g => metadata.Studios.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Studios.Add(studio);
+            }
+
+            // actors
+            foreach (Actor actor in metadata.Actors
+                         .Filter(
+                             a => incomingMetadata.Actors.All(
+                                 a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
+                         .ToList())
+            {
+                metadata.Actors.Remove(actor);
+            }
+
+            foreach (Actor actor in incomingMetadata.Actors
+                         .Filter(a => metadata.Actors.All(a2 => a2.Name != a.Name))
+                         .ToList())
+            {
+                metadata.Actors.Add(actor);
+            }
+
+            // guids
+            foreach (MetadataGuid guid in metadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Remove(guid);
+            }
+
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Add(guid);
+            }
+
+            metadata.ReleaseDate = incomingMetadata.ReleaseDate;
+
+            // poster
+            Artwork incomingPoster =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+            if (incomingPoster != null)
+            {
+                Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+                if (poster == null)
+                {
+                    poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
+                    metadata.Artwork.Add(poster);
+                }
+
+                poster.Path = incomingPoster.Path;
+                poster.DateAdded = incomingPoster.DateAdded;
+                poster.DateUpdated = incomingPoster.DateUpdated;
+            }
+
+            // thumbnail
+            Artwork incomingThumbnail =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
+            if (incomingThumbnail != null)
+            {
+                Artwork thumb = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
+                if (thumb == null)
+                {
+                    thumb = new Artwork { ArtworkKind = ArtworkKind.Thumbnail };
+                    metadata.Artwork.Add(thumb);
+                }
+
+                thumb.Path = incomingThumbnail.Path;
+                thumb.DateAdded = incomingThumbnail.DateAdded;
+                thumb.DateUpdated = incomingThumbnail.DateUpdated;
+            }
+
+            // fan art
+            Artwork incomingFanArt =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+            if (incomingFanArt != null)
+            {
+                Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+                if (fanArt == null)
+                {
+                    fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
+                    metadata.Artwork.Add(fanArt);
+                }
+
+                fanArt.Path = incomingFanArt.Path;
+                fanArt.DateAdded = incomingFanArt.DateAdded;
+                fanArt.DateUpdated = incomingFanArt.DateUpdated;
+            }
+
+            var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
+            foreach (Artwork artworkToRemove in metadata.Artwork
+                         .Filter(a => !paths.Contains(a.Path))
+                         .ToList())
+            {
+                metadata.Artwork.Remove(artworkToRemove);
+            }
+        }
+
+        await dbContext.SaveChangesAsync();
+
+        return maybeExisting;
+    }
+
+    public async Task<bool> AddSeason(JellyfinShow show, JellyfinSeason season)
+    {
+        try
+        {
+            season.ShowId = await _dbConnection.ExecuteScalarAsync<int>(
+                @"SELECT Id FROM JellyfinShow WHERE ItemId = @ItemId",
+                new { show.ItemId });
+
             await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            await dbContext.AddAsync(show);
+            await dbContext.AddAsync(season);
             if (await dbContext.SaveChangesAsync() <= 0)
             {
                 return false;
             }
 
-            await dbContext.Entry(show).Reference(m => m.LibraryPath).LoadAsync();
-            await dbContext.Entry(show.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            await dbContext.Entry(season).Reference(m => m.LibraryPath).LoadAsync();
+            await dbContext.Entry(season.LibraryPath).Reference(lp => lp.Library).LoadAsync();
             return true;
         }
-
-        public async Task<Option<JellyfinShow>> Update(JellyfinShow show)
+        catch (Exception)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<JellyfinShow> maybeExisting = await dbContext.JellyfinShows
-                .Include(m => m.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => m.ShowMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(m => m.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .Filter(m => m.ItemId == show.ItemId)
-                .OrderBy(m => m.ItemId)
-                .SingleOrDefaultAsync();
+            return false;
+        }
+    }
 
-            if (maybeExisting.IsSome)
+    public async Task<Option<JellyfinSeason>> Update(JellyfinSeason season)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<JellyfinSeason> maybeExisting = await dbContext.JellyfinSeasons
+            .Include(m => m.LibraryPath)
+            .Include(m => m.SeasonMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(m => m.SeasonMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Filter(m => m.ItemId == season.ItemId)
+            .OrderBy(m => m.ItemId)
+            .SingleOrDefaultAsync();
+
+        if (maybeExisting.IsSome)
+        {
+            JellyfinSeason existing = maybeExisting.ValueUnsafe();
+
+            // library path is used for search indexing later
+            season.LibraryPath = existing.LibraryPath;
+            season.Id = existing.Id;
+
+            existing.Etag = season.Etag;
+            existing.SeasonNumber = season.SeasonNumber;
+
+            // metadata
+            SeasonMetadata metadata = existing.SeasonMetadata.Head();
+            SeasonMetadata incomingMetadata = season.SeasonMetadata.Head();
+            metadata.Title = incomingMetadata.Title;
+            metadata.SortTitle = incomingMetadata.SortTitle;
+            metadata.Year = incomingMetadata.Year;
+            metadata.DateAdded = incomingMetadata.DateAdded;
+            metadata.DateUpdated = DateTime.UtcNow;
+            metadata.ReleaseDate = incomingMetadata.ReleaseDate;
+
+            // poster
+            Artwork incomingPoster =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+            if (incomingPoster != null)
             {
-                JellyfinShow existing = maybeExisting.ValueUnsafe();
-
-                // library path is used for search indexing later
-                show.LibraryPath = existing.LibraryPath;
-                show.Id = existing.Id;
-
-                existing.Etag = show.Etag;
-
-                // metadata
-                ShowMetadata metadata = existing.ShowMetadata.Head();
-                ShowMetadata incomingMetadata = show.ShowMetadata.Head();
-                metadata.MetadataKind = incomingMetadata.MetadataKind;
-                metadata.ContentRating = incomingMetadata.ContentRating;
-                metadata.Title = incomingMetadata.Title;
-                metadata.SortTitle = incomingMetadata.SortTitle;
-                metadata.Plot = incomingMetadata.Plot;
-                metadata.Year = incomingMetadata.Year;
-                metadata.Tagline = incomingMetadata.Tagline;
-                metadata.DateAdded = incomingMetadata.DateAdded;
-                metadata.DateUpdated = DateTime.UtcNow;
-
-                // genres
-                foreach (Genre genre in metadata.Genres
-                    .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
+                Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+                if (poster == null)
                 {
-                    metadata.Genres.Remove(genre);
+                    poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
+                    metadata.Artwork.Add(poster);
                 }
 
-                foreach (Genre genre in incomingMetadata.Genres
-                    .Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
+                poster.Path = incomingPoster.Path;
+                poster.DateAdded = incomingPoster.DateAdded;
+                poster.DateUpdated = incomingPoster.DateUpdated;
+            }
+
+            // fan art
+            Artwork incomingFanArt =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+            if (incomingFanArt != null)
+            {
+                Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+                if (fanArt == null)
                 {
-                    metadata.Genres.Add(genre);
+                    fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
+                    metadata.Artwork.Add(fanArt);
                 }
 
-                // tags
-                foreach (Tag tag in metadata.Tags
-                    .Filter(g => incomingMetadata.Tags.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Tags.Remove(tag);
-                }
+                fanArt.Path = incomingFanArt.Path;
+                fanArt.DateAdded = incomingFanArt.DateAdded;
+                fanArt.DateUpdated = incomingFanArt.DateUpdated;
+            }
 
-                foreach (Tag tag in incomingMetadata.Tags
-                    .Filter(g => metadata.Tags.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Tags.Add(tag);
-                }
+            // guids
+            foreach (MetadataGuid guid in metadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Remove(guid);
+            }
 
-                // studios
-                foreach (Studio studio in metadata.Studios
-                    .Filter(g => incomingMetadata.Studios.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Studios.Remove(studio);
-                }
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Add(guid);
+            }
 
-                foreach (Studio studio in incomingMetadata.Studios
-                    .Filter(g => metadata.Studios.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Studios.Add(studio);
-                }
-
-                // actors
-                foreach (Actor actor in metadata.Actors
-                    .Filter(
-                        a => incomingMetadata.Actors.All(
-                            a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
-                    .ToList())
-                {
-                    metadata.Actors.Remove(actor);
-                }
-
-                foreach (Actor actor in incomingMetadata.Actors
-                    .Filter(a => metadata.Actors.All(a2 => a2.Name != a.Name))
-                    .ToList())
-                {
-                    metadata.Actors.Add(actor);
-                }
-
-                // guids
-                foreach (MetadataGuid guid in metadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Remove(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Add(guid);
-                }
-
-                metadata.ReleaseDate = incomingMetadata.ReleaseDate;
-
-                // poster
-                Artwork incomingPoster =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                if (incomingPoster != null)
-                {
-                    Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                    if (poster == null)
-                    {
-                        poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
-                        metadata.Artwork.Add(poster);
-                    }
-
-                    poster.Path = incomingPoster.Path;
-                    poster.DateAdded = incomingPoster.DateAdded;
-                    poster.DateUpdated = incomingPoster.DateUpdated;
-                }
-
-                // thumbnail
-                Artwork incomingThumbnail =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
-                if (incomingThumbnail != null)
-                {
-                    Artwork thumb = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
-                    if (thumb == null)
-                    {
-                        thumb = new Artwork { ArtworkKind = ArtworkKind.Thumbnail };
-                        metadata.Artwork.Add(thumb);
-                    }
-
-                    thumb.Path = incomingThumbnail.Path;
-                    thumb.DateAdded = incomingThumbnail.DateAdded;
-                    thumb.DateUpdated = incomingThumbnail.DateUpdated;
-                }
-
-                // fan art
-                Artwork incomingFanArt =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                if (incomingFanArt != null)
-                {
-                    Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                    if (fanArt == null)
-                    {
-                        fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
-                        metadata.Artwork.Add(fanArt);
-                    }
-
-                    fanArt.Path = incomingFanArt.Path;
-                    fanArt.DateAdded = incomingFanArt.DateAdded;
-                    fanArt.DateUpdated = incomingFanArt.DateUpdated;
-                }
-
-                var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
-                foreach (Artwork artworkToRemove in metadata.Artwork
-                    .Filter(a => !paths.Contains(a.Path))
-                    .ToList())
-                {
-                    metadata.Artwork.Remove(artworkToRemove);
-                }
+            var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
+            foreach (Artwork artworkToRemove in metadata.Artwork
+                         .Filter(a => !paths.Contains(a.Path))
+                         .ToList())
+            {
+                metadata.Artwork.Remove(artworkToRemove);
             }
 
             await dbContext.SaveChangesAsync();
-
-            return maybeExisting;
+            await dbContext.Entry(existing.LibraryPath).Reference(lp => lp.Library).LoadAsync();
         }
 
-        public async Task<bool> AddSeason(JellyfinShow show, JellyfinSeason season)
+        return maybeExisting;
+    }
+
+    public async Task<bool> AddEpisode(JellyfinSeason season, JellyfinEpisode episode)
+    {
+        try
         {
-            try
-            {
-                season.ShowId = await _dbConnection.ExecuteScalarAsync<int>(
-                    @"SELECT Id FROM JellyfinShow WHERE ItemId = @ItemId",
-                    new { show.ItemId });
+            episode.SeasonId = await _dbConnection.ExecuteScalarAsync<int>(
+                @"SELECT Id FROM JellyfinSeason WHERE ItemId = @ItemId",
+                new { season.ItemId });
 
-                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-                await dbContext.AddAsync(season);
-                if (await dbContext.SaveChangesAsync() <= 0)
-                {
-                    return false;
-                }
-
-                await dbContext.Entry(season).Reference(m => m.LibraryPath).LoadAsync();
-                await dbContext.Entry(season.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return true;
-            }
-            catch (Exception)
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await dbContext.AddAsync(episode);
+            if (await dbContext.SaveChangesAsync() <= 0)
             {
                 return false;
             }
+
+            await dbContext.Entry(episode).Reference(m => m.LibraryPath).LoadAsync();
+            await dbContext.Entry(episode.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            await dbContext.Entry(episode).Reference(e => e.Season).LoadAsync();
+            return true;
         }
-
-        public async Task<Option<JellyfinSeason>> Update(JellyfinSeason season)
+        catch (Exception)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<JellyfinSeason> maybeExisting = await dbContext.JellyfinSeasons
-                .Include(m => m.LibraryPath)
-                .Include(m => m.SeasonMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => m.SeasonMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Filter(m => m.ItemId == season.ItemId)
-                .OrderBy(m => m.ItemId)
-                .SingleOrDefaultAsync();
+            return false;
+        }
+    }
 
-            if (maybeExisting.IsSome)
+    public async Task<Option<JellyfinEpisode>> Update(JellyfinEpisode episode)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<JellyfinEpisode> maybeExisting = await dbContext.JellyfinEpisodes
+            .Include(m => m.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(m => m.EpisodeMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(m => m.Season)
+            .Include(m => m.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .Filter(m => m.ItemId == episode.ItemId)
+            .OrderBy(m => m.ItemId)
+            .SingleOrDefaultAsync();
+
+        if (maybeExisting.IsSome)
+        {
+            JellyfinEpisode existing = maybeExisting.ValueUnsafe();
+
+            // library path is used for search indexing later
+            episode.LibraryPath = existing.LibraryPath;
+            episode.Id = existing.Id;
+
+            existing.Etag = episode.Etag;
+
+            // metadata
+            // TODO: multiple metadata?
+            EpisodeMetadata metadata = existing.EpisodeMetadata.Head();
+            EpisodeMetadata incomingMetadata = episode.EpisodeMetadata.Head();
+            metadata.Title = incomingMetadata.Title;
+            metadata.SortTitle = incomingMetadata.SortTitle;
+            metadata.Plot = incomingMetadata.Plot;
+            metadata.Year = incomingMetadata.Year;
+            metadata.DateAdded = incomingMetadata.DateAdded;
+            metadata.DateUpdated = DateTime.UtcNow;
+            metadata.ReleaseDate = incomingMetadata.ReleaseDate;
+            metadata.EpisodeNumber = metadata.EpisodeNumber;
+
+            // thumbnail
+            Artwork incomingThumbnail =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
+            if (incomingThumbnail != null)
             {
-                JellyfinSeason existing = maybeExisting.ValueUnsafe();
-
-                // library path is used for search indexing later
-                season.LibraryPath = existing.LibraryPath;
-                season.Id = existing.Id;
-
-                existing.Etag = season.Etag;
-                existing.SeasonNumber = season.SeasonNumber;
-
-                // metadata
-                SeasonMetadata metadata = existing.SeasonMetadata.Head();
-                SeasonMetadata incomingMetadata = season.SeasonMetadata.Head();
-                metadata.Title = incomingMetadata.Title;
-                metadata.SortTitle = incomingMetadata.SortTitle;
-                metadata.Year = incomingMetadata.Year;
-                metadata.DateAdded = incomingMetadata.DateAdded;
-                metadata.DateUpdated = DateTime.UtcNow;
-                metadata.ReleaseDate = incomingMetadata.ReleaseDate;
-
-                // poster
-                Artwork incomingPoster =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                if (incomingPoster != null)
+                Artwork thumbnail = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
+                if (thumbnail == null)
                 {
-                    Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                    if (poster == null)
-                    {
-                        poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
-                        metadata.Artwork.Add(poster);
-                    }
-
-                    poster.Path = incomingPoster.Path;
-                    poster.DateAdded = incomingPoster.DateAdded;
-                    poster.DateUpdated = incomingPoster.DateUpdated;
+                    thumbnail = new Artwork { ArtworkKind = ArtworkKind.Thumbnail };
+                    metadata.Artwork.Add(thumbnail);
                 }
 
-                // fan art
-                Artwork incomingFanArt =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                if (incomingFanArt != null)
-                {
-                    Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                    if (fanArt == null)
-                    {
-                        fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
-                        metadata.Artwork.Add(fanArt);
-                    }
-
-                    fanArt.Path = incomingFanArt.Path;
-                    fanArt.DateAdded = incomingFanArt.DateAdded;
-                    fanArt.DateUpdated = incomingFanArt.DateUpdated;
-                }
-
-                // guids
-                foreach (MetadataGuid guid in metadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Remove(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Add(guid);
-                }
-
-                var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
-                foreach (Artwork artworkToRemove in metadata.Artwork
-                    .Filter(a => !paths.Contains(a.Path))
-                    .ToList())
-                {
-                    metadata.Artwork.Remove(artworkToRemove);
-                }
-
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(existing.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+                thumbnail.Path = incomingThumbnail.Path;
+                thumbnail.DateAdded = incomingThumbnail.DateAdded;
+                thumbnail.DateUpdated = incomingThumbnail.DateUpdated;
             }
 
-            return maybeExisting;
-        }
-
-        public async Task<bool> AddEpisode(JellyfinSeason season, JellyfinEpisode episode)
-        {
-            try
+            // directors
+            foreach (Director director in metadata.Directors
+                         .Filter(d => incomingMetadata.Directors.All(d2 => d2.Name != d.Name))
+                         .ToList())
             {
-                episode.SeasonId = await _dbConnection.ExecuteScalarAsync<int>(
-                    @"SELECT Id FROM JellyfinSeason WHERE ItemId = @ItemId",
-                    new { season.ItemId });
-
-                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-                await dbContext.AddAsync(episode);
-                if (await dbContext.SaveChangesAsync() <= 0)
-                {
-                    return false;
-                }
-
-                await dbContext.Entry(episode).Reference(m => m.LibraryPath).LoadAsync();
-                await dbContext.Entry(episode.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                await dbContext.Entry(episode).Reference(e => e.Season).LoadAsync();
-                return true;
-            }
-            catch (Exception)
-            {
-                return false;
-            }
-        }
-
-        public async Task<Option<JellyfinEpisode>> Update(JellyfinEpisode episode)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<JellyfinEpisode> maybeExisting = await dbContext.JellyfinEpisodes
-                .Include(m => m.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(m => m.EpisodeMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(m => m.Season)
-                .Include(m => m.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .Filter(m => m.ItemId == episode.ItemId)
-                .OrderBy(m => m.ItemId)
-                .SingleOrDefaultAsync();
-
-            if (maybeExisting.IsSome)
-            {
-                JellyfinEpisode existing = maybeExisting.ValueUnsafe();
-
-                // library path is used for search indexing later
-                episode.LibraryPath = existing.LibraryPath;
-                episode.Id = existing.Id;
-
-                existing.Etag = episode.Etag;
-
-                // metadata
-                // TODO: multiple metadata?
-                EpisodeMetadata metadata = existing.EpisodeMetadata.Head();
-                EpisodeMetadata incomingMetadata = episode.EpisodeMetadata.Head();
-                metadata.Title = incomingMetadata.Title;
-                metadata.SortTitle = incomingMetadata.SortTitle;
-                metadata.Plot = incomingMetadata.Plot;
-                metadata.Year = incomingMetadata.Year;
-                metadata.DateAdded = incomingMetadata.DateAdded;
-                metadata.DateUpdated = DateTime.UtcNow;
-                metadata.ReleaseDate = incomingMetadata.ReleaseDate;
-                metadata.EpisodeNumber = metadata.EpisodeNumber;
-
-                // thumbnail
-                Artwork incomingThumbnail =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
-                if (incomingThumbnail != null)
-                {
-                    Artwork thumbnail = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Thumbnail);
-                    if (thumbnail == null)
-                    {
-                        thumbnail = new Artwork { ArtworkKind = ArtworkKind.Thumbnail };
-                        metadata.Artwork.Add(thumbnail);
-                    }
-
-                    thumbnail.Path = incomingThumbnail.Path;
-                    thumbnail.DateAdded = incomingThumbnail.DateAdded;
-                    thumbnail.DateUpdated = incomingThumbnail.DateUpdated;
-                }
-
-                // directors
-                foreach (Director director in metadata.Directors
-                    .Filter(d => incomingMetadata.Directors.All(d2 => d2.Name != d.Name))
-                    .ToList())
-                {
-                    metadata.Directors.Remove(director);
-                }
-
-                foreach (Director director in incomingMetadata.Directors
-                    .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name))
-                    .ToList())
-                {
-                    metadata.Directors.Add(director);
-                }
-
-                // writers
-                foreach (Writer writer in metadata.Writers
-                    .Filter(w => incomingMetadata.Writers.All(w2 => w2.Name != w.Name))
-                    .ToList())
-                {
-                    metadata.Writers.Remove(writer);
-                }
-
-                foreach (Writer writer in incomingMetadata.Writers
-                    .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name))
-                    .ToList())
-                {
-                    metadata.Writers.Add(writer);
-                }
-
-                // guids
-                foreach (MetadataGuid guid in metadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Remove(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Add(guid);
-                }
-
-                var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
-                foreach (Artwork artworkToRemove in metadata.Artwork
-                    .Filter(a => !paths.Contains(a.Path))
-                    .ToList())
-                {
-                    metadata.Artwork.Remove(artworkToRemove);
-                }
-
-                // version
-                MediaVersion version = existing.MediaVersions.Head();
-                MediaVersion incomingVersion = episode.MediaVersions.Head();
-                version.Name = incomingVersion.Name;
-                version.DateAdded = incomingVersion.DateAdded;
-
-                // media file
-                MediaFile file = version.MediaFiles.Head();
-                MediaFile incomingFile = incomingVersion.MediaFiles.Head();
-                file.Path = incomingFile.Path;
+                metadata.Directors.Remove(director);
             }
 
-            await dbContext.SaveChangesAsync();
+            foreach (Director director in incomingMetadata.Directors
+                         .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name))
+                         .ToList())
+            {
+                metadata.Directors.Add(director);
+            }
 
-            return maybeExisting;
+            // writers
+            foreach (Writer writer in metadata.Writers
+                         .Filter(w => incomingMetadata.Writers.All(w2 => w2.Name != w.Name))
+                         .ToList())
+            {
+                metadata.Writers.Remove(writer);
+            }
+
+            foreach (Writer writer in incomingMetadata.Writers
+                         .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name))
+                         .ToList())
+            {
+                metadata.Writers.Add(writer);
+            }
+
+            // guids
+            foreach (MetadataGuid guid in metadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Remove(guid);
+            }
+
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Add(guid);
+            }
+
+            var paths = incomingMetadata.Artwork.Map(a => a.Path).ToList();
+            foreach (Artwork artworkToRemove in metadata.Artwork
+                         .Filter(a => !paths.Contains(a.Path))
+                         .ToList())
+            {
+                metadata.Artwork.Remove(artworkToRemove);
+            }
+
+            // version
+            MediaVersion version = existing.MediaVersions.Head();
+            MediaVersion incomingVersion = episode.MediaVersions.Head();
+            version.Name = incomingVersion.Name;
+            version.DateAdded = incomingVersion.DateAdded;
+
+            // media file
+            MediaFile file = version.MediaFiles.Head();
+            MediaFile incomingFile = incomingVersion.MediaFiles.Head();
+            file.Path = incomingFile.Path;
         }
 
-        public async Task<List<int>> RemoveMissingShows(JellyfinLibrary library, List<string> showIds)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        await dbContext.SaveChangesAsync();
+
+        return maybeExisting;
+    }
+
+    public async Task<List<int>> RemoveMissingShows(JellyfinLibrary library, List<string> showIds)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinShow js ON js.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 WHERE lp.LibraryId = @LibraryId AND js.ItemId IN @ShowIds",
-                new { LibraryId = library.Id, ShowIds = showIds }).Map(result => result.ToList());
+            new { LibraryId = library.Id, ShowIds = showIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
-        }
+        return ids;
+    }
 
-        public Task<Unit> RemoveMissingSeasons(JellyfinLibrary library, List<string> seasonIds) =>
-            _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+    public Task<Unit> RemoveMissingSeasons(JellyfinLibrary library, List<string> seasonIds) =>
+        _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinSeason js ON js.Id = m.Id
                 INNER JOIN LibraryPath LP on m.LibraryPathId = LP.Id
                 WHERE LP.LibraryId = @LibraryId AND js.ItemId IN @SeasonIds)",
-                new { LibraryId = library.Id, SeasonIds = seasonIds }).ToUnit();
+            new { LibraryId = library.Id, SeasonIds = seasonIds }).ToUnit();
 
-        public async Task<List<int>> RemoveMissingEpisodes(JellyfinLibrary library, List<string> episodeIds)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+    public async Task<List<int>> RemoveMissingEpisodes(JellyfinLibrary library, List<string> episodeIds)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinEpisode je ON je.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 WHERE lp.LibraryId = @LibraryId AND je.ItemId IN @EpisodeIds",
-                new { LibraryId = library.Id, EpisodeIds = episodeIds }).Map(result => result.ToList());
+            new { LibraryId = library.Id, EpisodeIds = episodeIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
-        }
-
-        public async Task<Unit> DeleteEmptySeasons(JellyfinLibrary library)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<JellyfinSeason> seasons = await dbContext.JellyfinSeasons
-                .Filter(s => s.LibraryPath.LibraryId == library.Id)
-                .Filter(s => s.Episodes.Count == 0)
-                .ToListAsync();
-            dbContext.Seasons.RemoveRange(seasons);
-            await dbContext.SaveChangesAsync();
-            return Unit.Default;
-        }
-
-        public async Task<List<int>> DeleteEmptyShows(JellyfinLibrary library)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<JellyfinShow> shows = await dbContext.JellyfinShows
-                .Filter(s => s.LibraryPath.LibraryId == library.Id)
-                .Filter(s => s.Seasons.Count == 0)
-                .ToListAsync();
-            var ids = shows.Map(s => s.Id).ToList();
-            dbContext.Shows.RemoveRange(shows);
-            await dbContext.SaveChangesAsync();
-            return ids;
-        }
+        return ids;
     }
-}
+
+    public async Task<Unit> DeleteEmptySeasons(JellyfinLibrary library)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<JellyfinSeason> seasons = await dbContext.JellyfinSeasons
+            .Filter(s => s.LibraryPath.LibraryId == library.Id)
+            .Filter(s => s.Episodes.Count == 0)
+            .ToListAsync();
+        dbContext.Seasons.RemoveRange(seasons);
+        await dbContext.SaveChangesAsync();
+        return Unit.Default;
+    }
+
+    public async Task<List<int>> DeleteEmptyShows(JellyfinLibrary library)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<JellyfinShow> shows = await dbContext.JellyfinShows
+            .Filter(s => s.LibraryPath.LibraryId == library.Id)
+            .Filter(s => s.Seasons.Count == 0)
+            .ToListAsync();
+        var ids = shows.Map(s => s.Id).ToList();
+        dbContext.Shows.RemoveRange(shows);
+        await dbContext.SaveChangesAsync();
+        return ids;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/LibraryRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/LibraryRepository.cs
index cbfe2b5f8..dad1a96e8 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/LibraryRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/LibraryRepository.cs
@@ -1,159 +1,153 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class LibraryRepository : ILibraryRepository
 {
-    public class LibraryRepository : ILibraryRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public LibraryRepository(
+        ILocalFileSystem localFileSystem,
+        IDbContextFactory<TvContext> dbContextFactory,
+        IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _localFileSystem = localFileSystem;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public LibraryRepository(
-            ILocalFileSystem localFileSystem,
-            IDbContextFactory<TvContext> dbContextFactory,
-            IDbConnection dbConnection)
-        {
-            _localFileSystem = localFileSystem;
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<LibraryPath> Add(LibraryPath libraryPath)
+    {
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+        await context.LibraryPaths.AddAsync(libraryPath);
+        await context.SaveChangesAsync();
+        return libraryPath;
+    }
 
-        public async Task<LibraryPath> Add(LibraryPath libraryPath)
-        {
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            await context.LibraryPaths.AddAsync(libraryPath);
-            await context.SaveChangesAsync();
-            return libraryPath;
-        }
+    public Task<Option<Library>> Get(int libraryId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.Libraries
+            .Include(l => l.Paths)
+            .ThenInclude(p => p.LibraryFolders)
+            .OrderBy(l => l.Id)
+            .SingleOrDefaultAsync(l => l.Id == libraryId)
+            .Map(Optional);
+    }
 
-        public Task<Option<Library>> Get(int libraryId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.Libraries
-                .Include(l => l.Paths)
-                .ThenInclude(p => p.LibraryFolders)
-                .OrderBy(l => l.Id)
-                .SingleOrDefaultAsync(l => l.Id == libraryId)
-                .Map(Optional);
-        }
+    public Task<Option<LocalLibrary>> GetLocal(int libraryId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.LocalLibraries
+            .OrderBy(l => l.Id)
+            .SingleOrDefaultAsync(l => l.Id == libraryId)
+            .Map(Optional);
+    }
 
-        public Task<Option<LocalLibrary>> GetLocal(int libraryId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.LocalLibraries
-                .OrderBy(l => l.Id)
-                .SingleOrDefaultAsync(l => l.Id == libraryId)
-                .Map(Optional);
-        }
+    public Task<List<Library>> GetAll()
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.Libraries
+            .AsNoTracking()
+            .Include(l => l.MediaSource)
+            .Include(l => l.Paths)
+            .ToListAsync();
+    }
 
-        public Task<List<Library>> GetAll()
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.Libraries
-                .AsNoTracking()
-                .Include(l => l.MediaSource)
-                .Include(l => l.Paths)
-                .ToListAsync();
-        }
+    public Task<Unit> UpdateLastScan(Library library) => _dbConnection.ExecuteAsync(
+        "UPDATE Library SET LastScan = @LastScan WHERE Id = @Id",
+        new { library.LastScan, library.Id }).ToUnit();
 
-        public Task<Unit> UpdateLastScan(Library library) => _dbConnection.ExecuteAsync(
-            "UPDATE Library SET LastScan = @LastScan WHERE Id = @Id",
-            new { library.LastScan, library.Id }).ToUnit();
+    public Task<Unit> UpdateLastScan(LibraryPath libraryPath) => _dbConnection.ExecuteAsync(
+        "UPDATE LibraryPath SET LastScan = @LastScan WHERE Id = @Id",
+        new { libraryPath.LastScan, libraryPath.Id }).ToUnit();
 
-        public Task<Unit> UpdateLastScan(LibraryPath libraryPath) => _dbConnection.ExecuteAsync(
-            "UPDATE LibraryPath SET LastScan = @LastScan WHERE Id = @Id",
-            new { libraryPath.LastScan, libraryPath.Id }).ToUnit();
+    public Task<List<LibraryPath>> GetLocalPaths(int libraryId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.LocalLibraries
+            .Include(l => l.Paths)
+            .OrderBy(l => l.Id)
+            .SingleOrDefaultAsync(l => l.Id == libraryId)
+            .Map(Optional)
+            .Match(l => l.Paths, () => new List<LibraryPath>());
+    }
 
-        public Task<List<LibraryPath>> GetLocalPaths(int libraryId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.LocalLibraries
-                .Include(l => l.Paths)
-                .OrderBy(l => l.Id)
-                .SingleOrDefaultAsync(l => l.Id == libraryId)
-                .Map(Optional)
-                .Match(l => l.Paths, () => new List<LibraryPath>());
-        }
+    public Task<Option<LibraryPath>> GetPath(int libraryPathId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.LibraryPaths
+            .OrderBy(lp => lp.Id)
+            .SingleOrDefaultAsync(lp => lp.Id == libraryPathId)
+            .Map(Optional);
+    }
 
-        public Task<Option<LibraryPath>> GetPath(int libraryPathId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.LibraryPaths
-                .OrderBy(lp => lp.Id)
-                .SingleOrDefaultAsync(lp => lp.Id == libraryPathId)
-                .Map(Optional);
-        }
+    public Task<int> CountMediaItemsByPath(int libraryPathId) =>
+        _dbConnection.QuerySingleAsync<int>(
+            @"SELECT COUNT(*) FROM MediaItem WHERE LibraryPathId = @LibraryPathId",
+            new { LibraryPathId = libraryPathId });
 
-        public Task<int> CountMediaItemsByPath(int libraryPathId) =>
-            _dbConnection.QuerySingleAsync<int>(
-                @"SELECT COUNT(*) FROM MediaItem WHERE LibraryPathId = @LibraryPathId",
-                new { LibraryPathId = libraryPathId });
+    public Task<List<int>> GetMediaIdsByLocalPath(int libraryPathId) =>
+        _dbConnection.QueryAsync<int>(
+                @"SELECT Id FROM MediaItem WHERE LibraryPathId = @LibraryPathId",
+                new { LibraryPathId = libraryPathId })
+            .Map(result => result.ToList());
 
-        public Task<List<int>> GetMediaIdsByLocalPath(int libraryPathId) =>
-            _dbConnection.QueryAsync<int>(
-                    @"SELECT Id FROM MediaItem WHERE LibraryPathId = @LibraryPathId",
-                    new { LibraryPathId = libraryPathId })
-                .Map(result => result.ToList());
+    public async Task DeleteLocalPath(int libraryPathId)
+    {
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+        LibraryPath libraryPath = await context.LibraryPaths.FindAsync(libraryPathId);
+        context.LibraryPaths.Remove(libraryPath);
+        await context.SaveChangesAsync();
+    }
 
-        public async Task DeleteLocalPath(int libraryPathId)
-        {
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            LibraryPath libraryPath = await context.LibraryPaths.FindAsync(libraryPathId);
-            context.LibraryPaths.Remove(libraryPath);
-            await context.SaveChangesAsync();
-        }
-
-        public Task<Unit> SetEtag(
-            LibraryPath libraryPath,
-            Option<LibraryFolder> knownFolder,
-            string path,
-            string etag) =>
-            knownFolder.Match(
-                async folder =>
-                {
-                    await _dbConnection.ExecuteAsync(
-                        "UPDATE LibraryFolder SET Etag = @Etag WHERE Id = @Id",
-                        new { folder.Id, Etag = etag });
-                },
-                async () =>
-                {
-                    await using TvContext context = await _dbContextFactory.CreateDbContextAsync();
-                    await context.LibraryFolders.AddAsync(
-                        new LibraryFolder
-                        {
-                            Path = path,
-                            Etag = etag,
-                            LibraryPathId = libraryPath.Id
-                        });
-                    await context.SaveChangesAsync();
-                }).ToUnit();
-
-        public async Task<Unit> CleanEtagsForLibraryPath(LibraryPath libraryPath)
-        {
-            IEnumerable<string> folders = await _dbConnection.QueryAsync<string>(
-                @"SELECT LF.Path
-                FROM LibraryFolder LF
-                WHERE LF.LibraryPathId = @LibraryPathId",
-                new { LibraryPathId = libraryPath.Id });
-
-            foreach (string folder in folders.Where(f => !_localFileSystem.FolderExists(f)))
+    public Task<Unit> SetEtag(
+        LibraryPath libraryPath,
+        Option<LibraryFolder> knownFolder,
+        string path,
+        string etag) =>
+        knownFolder.Match(
+            async folder =>
             {
                 await _dbConnection.ExecuteAsync(
-                    @"DELETE FROM LibraryFolder WHERE LibraryPathId = @LibraryPathId AND Path = @Path",
-                    new { LibraryPathId = libraryPath.Id, Path = folder });
-            }
+                    "UPDATE LibraryFolder SET Etag = @Etag WHERE Id = @Id",
+                    new { folder.Id, Etag = etag });
+            },
+            async () =>
+            {
+                await using TvContext context = await _dbContextFactory.CreateDbContextAsync();
+                await context.LibraryFolders.AddAsync(
+                    new LibraryFolder
+                    {
+                        Path = path,
+                        Etag = etag,
+                        LibraryPathId = libraryPath.Id
+                    });
+                await context.SaveChangesAsync();
+            }).ToUnit();
 
-            return Unit.Default;
+    public async Task<Unit> CleanEtagsForLibraryPath(LibraryPath libraryPath)
+    {
+        IEnumerable<string> folders = await _dbConnection.QueryAsync<string>(
+            @"SELECT LF.Path
+                FROM LibraryFolder LF
+                WHERE LF.LibraryPathId = @LibraryPathId",
+            new { LibraryPathId = libraryPath.Id });
+
+        foreach (string folder in folders.Where(f => !_localFileSystem.FolderExists(f)))
+        {
+            await _dbConnection.ExecuteAsync(
+                @"DELETE FROM LibraryFolder WHERE LibraryPathId = @LibraryPathId AND Path = @Path",
+                new { LibraryPathId = libraryPath.Id, Path = folder });
         }
+
+        return Unit.Default;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs
index a0038d578..987772f33 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs
@@ -1,7 +1,4 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
@@ -10,640 +7,637 @@ using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Core.Search;
 using ErsatzTV.Infrastructure.Extensions;
 using ErsatzTV.Infrastructure.Search;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class MediaCollectionRepository : IMediaCollectionRepository
 {
-    public class MediaCollectionRepository : IMediaCollectionRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly ISearchIndex _searchIndex;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public MediaCollectionRepository(
+        ISearchIndex searchIndex,
+        IDbContextFactory<TvContext> dbContextFactory,
+        IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly ISearchIndex _searchIndex;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _searchIndex = searchIndex;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public MediaCollectionRepository(
-            ISearchIndex searchIndex,
-            IDbContextFactory<TvContext> dbContextFactory,
-            IDbConnection dbConnection)
+    public async Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Collections
+            .Include(c => c.CollectionItems)
+            .OrderBy(c => c.Id)
+            .SingleOrDefaultAsync(c => c.Id == id)
+            .Map(Optional);
+    }
+
+    public async Task<List<MediaItem>> GetItems(int collectionId)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+
+        var result = new List<MediaItem>();
+
+        result.AddRange(await GetMovieItems(dbContext, collectionId));
+        result.AddRange(await GetShowItems(dbContext, collectionId));
+        result.AddRange(await GetSeasonItems(dbContext, collectionId));
+        result.AddRange(await GetEpisodeItems(dbContext, collectionId));
+        result.AddRange(await GetArtistItems(dbContext, collectionId));
+        result.AddRange(await GetMusicVideoItems(dbContext, collectionId));
+        result.AddRange(await GetOtherVideoItems(dbContext, collectionId));
+        result.AddRange(await GetSongItems(dbContext, collectionId));
+
+        return result.Distinct().ToList();
+    }
+
+    public async Task<List<MediaItem>> GetMultiCollectionItems(int id)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+
+        var result = new List<MediaItem>();
+
+        Option<MultiCollection> maybeMultiCollection = await dbContext.MultiCollections
+            .Include(mc => mc.Collections)
+            .Include(mc => mc.SmartCollections)
+            .SelectOneAsync(mc => mc.Id, mc => mc.Id == id);
+
+        foreach (MultiCollection multiCollection in maybeMultiCollection)
         {
-            _searchIndex = searchIndex;
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
-
-        public async Task<Option<Collection>> GetCollectionWithCollectionItemsUntracked(int id)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Collections
-                .Include(c => c.CollectionItems)
-                .OrderBy(c => c.Id)
-                .SingleOrDefaultAsync(c => c.Id == id)
-                .Map(Optional);
-        }
-
-        public async Task<List<MediaItem>> GetItems(int collectionId)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-
-            var result = new List<MediaItem>();
-
-            result.AddRange(await GetMovieItems(dbContext, collectionId));
-            result.AddRange(await GetShowItems(dbContext, collectionId));
-            result.AddRange(await GetSeasonItems(dbContext, collectionId));
-            result.AddRange(await GetEpisodeItems(dbContext, collectionId));
-            result.AddRange(await GetArtistItems(dbContext, collectionId));
-            result.AddRange(await GetMusicVideoItems(dbContext, collectionId));
-            result.AddRange(await GetOtherVideoItems(dbContext, collectionId));
-            result.AddRange(await GetSongItems(dbContext, collectionId));
-
-            return result.Distinct().ToList();
-        }
-
-        public async Task<List<MediaItem>> GetMultiCollectionItems(int id)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-
-            var result = new List<MediaItem>();
-
-            Option<MultiCollection> maybeMultiCollection = await dbContext.MultiCollections
-                .Include(mc => mc.Collections)
-                .Include(mc => mc.SmartCollections)
-                .SelectOneAsync(mc => mc.Id, mc => mc.Id == id);
-
-            foreach (MultiCollection multiCollection in maybeMultiCollection)
+            foreach (int collectionId in multiCollection.Collections.Map(c => c.Id))
             {
-                foreach (int collectionId in multiCollection.Collections.Map(c => c.Id))
-                {
-                    result.AddRange(await GetMovieItems(dbContext, collectionId));
-                    result.AddRange(await GetShowItems(dbContext, collectionId));
-                    result.AddRange(await GetSeasonItems(dbContext, collectionId));
-                    result.AddRange(await GetEpisodeItems(dbContext, collectionId));
-                    result.AddRange(await GetArtistItems(dbContext, collectionId));
-                    result.AddRange(await GetMusicVideoItems(dbContext, collectionId));
-                    result.AddRange(await GetOtherVideoItems(dbContext, collectionId));
-                    result.AddRange(await GetSongItems(dbContext, collectionId));
-                }
-
-                foreach (int smartCollectionId in multiCollection.SmartCollections.Map(c => c.Id))
-                {
-                    result.AddRange(await GetSmartCollectionItems(smartCollectionId));
-                }
+                result.AddRange(await GetMovieItems(dbContext, collectionId));
+                result.AddRange(await GetShowItems(dbContext, collectionId));
+                result.AddRange(await GetSeasonItems(dbContext, collectionId));
+                result.AddRange(await GetEpisodeItems(dbContext, collectionId));
+                result.AddRange(await GetArtistItems(dbContext, collectionId));
+                result.AddRange(await GetMusicVideoItems(dbContext, collectionId));
+                result.AddRange(await GetOtherVideoItems(dbContext, collectionId));
+                result.AddRange(await GetSongItems(dbContext, collectionId));
             }
+
+            foreach (int smartCollectionId in multiCollection.SmartCollections.Map(c => c.Id))
+            {
+                result.AddRange(await GetSmartCollectionItems(smartCollectionId));
+            }
+        }
             
-            return result.Distinct().ToList();
-        }
+        return result.Distinct().ToList();
+    }
 
-        public async Task<List<MediaItem>> GetSmartCollectionItems(int id)
+    public async Task<List<MediaItem>> GetSmartCollectionItems(int id)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+
+        var result = new List<MediaItem>();
+
+        Option<SmartCollection> maybeCollection = await dbContext.SmartCollections
+            .SelectOneAsync(sc => sc.Id, sc => sc.Id == id);
+
+        foreach (SmartCollection collection in maybeCollection)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+            SearchResult searchResults = await _searchIndex.Search(collection.Query, 0, 0);
+                
+            var movieIds = searchResults.Items
+                .Filter(i => i.Type == SearchIndex.MovieType)
+                .Map(i => i.Id)
+                .ToList();
+            result.AddRange(await GetMovieItems(dbContext, movieIds));
 
-            var result = new List<MediaItem>();
-
-            Option<SmartCollection> maybeCollection = await dbContext.SmartCollections
-                .SelectOneAsync(sc => sc.Id, sc => sc.Id == id);
-
-            foreach (SmartCollection collection in maybeCollection)
+            foreach (int showId in searchResults.Items.Filter(i => i.Type == SearchIndex.ShowType).Map(i => i.Id))
             {
-                SearchResult searchResults = await _searchIndex.Search(collection.Query, 0, 0);
-                
-                var movieIds = searchResults.Items
-                    .Filter(i => i.Type == SearchIndex.MovieType)
-                    .Map(i => i.Id)
-                    .ToList();
-                result.AddRange(await GetMovieItems(dbContext, movieIds));
-
-                foreach (int showId in searchResults.Items.Filter(i => i.Type == SearchIndex.ShowType).Map(i => i.Id))
-                {
-                    result.AddRange(await GetShowItemsFromShowId(dbContext, showId));
-                }
-
-                foreach (int seasonId in searchResults.Items.Filter(i => i.Type == SearchIndex.SeasonType)
-                    .Map(i => i.Id))
-                {
-                    result.AddRange(await GetSeasonItemsFromSeasonId(dbContext, seasonId));
-                }
-
-                foreach (int artistId in searchResults.Items.Filter(i => i.Type == SearchIndex.ArtistType)
-                    .Map(i => i.Id))
-                {
-                    result.AddRange(await GetArtistItemsFromArtistId(dbContext, artistId));
-                }
-
-                var musicVideoIds = searchResults.Items
-                    .Filter(i => i.Type == SearchIndex.MusicVideoType)
-                    .Map(i => i.Id)
-                    .ToList();
-                result.AddRange(await GetMusicVideoItems(dbContext, musicVideoIds));
-                
-                var episodeIds = searchResults.Items
-                    .Filter(i => i.Type == SearchIndex.EpisodeType)
-                    .Map(i => i.Id)
-                    .ToList();
-                result.AddRange(await GetEpisodeItems(dbContext, episodeIds));
-
-                var otherVideoIds = searchResults.Items
-                    .Filter(i => i.Type == SearchIndex.OtherVideoType)
-                    .Map(i => i.Id)
-                    .ToList();
-                result.AddRange(await GetOtherVideoItems(dbContext, otherVideoIds));
-
-                var songIds = searchResults.Items
-                    .Filter(i => i.Type == SearchIndex.SongType)
-                    .Map(i => i.Id)
-                    .ToList();
-                result.AddRange(await GetSongItems(dbContext, songIds));
+                result.AddRange(await GetShowItemsFromShowId(dbContext, showId));
             }
 
-            return result;
+            foreach (int seasonId in searchResults.Items.Filter(i => i.Type == SearchIndex.SeasonType)
+                         .Map(i => i.Id))
+            {
+                result.AddRange(await GetSeasonItemsFromSeasonId(dbContext, seasonId));
+            }
+
+            foreach (int artistId in searchResults.Items.Filter(i => i.Type == SearchIndex.ArtistType)
+                         .Map(i => i.Id))
+            {
+                result.AddRange(await GetArtistItemsFromArtistId(dbContext, artistId));
+            }
+
+            var musicVideoIds = searchResults.Items
+                .Filter(i => i.Type == SearchIndex.MusicVideoType)
+                .Map(i => i.Id)
+                .ToList();
+            result.AddRange(await GetMusicVideoItems(dbContext, musicVideoIds));
+                
+            var episodeIds = searchResults.Items
+                .Filter(i => i.Type == SearchIndex.EpisodeType)
+                .Map(i => i.Id)
+                .ToList();
+            result.AddRange(await GetEpisodeItems(dbContext, episodeIds));
+
+            var otherVideoIds = searchResults.Items
+                .Filter(i => i.Type == SearchIndex.OtherVideoType)
+                .Map(i => i.Id)
+                .ToList();
+            result.AddRange(await GetOtherVideoItems(dbContext, otherVideoIds));
+
+            var songIds = searchResults.Items
+                .Filter(i => i.Type == SearchIndex.SongType)
+                .Map(i => i.Id)
+                .ToList();
+            result.AddRange(await GetSongItems(dbContext, songIds));
         }
 
-        public async Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id)
+        return result;
+    }
+
+    public async Task<List<CollectionWithItems>> GetMultiCollectionCollections(int id)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+
+        var result = new List<CollectionWithItems>();
+
+        Option<MultiCollection> maybeMultiCollection = await dbContext.MultiCollections
+            .Include(mc => mc.Collections)
+            .Include(mc => mc.SmartCollections)
+            .Include(mc => mc.MultiCollectionItems)
+            .ThenInclude(mci => mci.Collection)
+            .Include(mc => mc.MultiCollectionSmartItems)
+            .ThenInclude(mci => mci.SmartCollection)
+            .SelectOneAsync(mc => mc.Id, mc => mc.Id == id);
+
+        foreach (MultiCollection multiCollection in maybeMultiCollection)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-
-            var result = new List<CollectionWithItems>();
-
-            Option<MultiCollection> maybeMultiCollection = await dbContext.MultiCollections
-                .Include(mc => mc.Collections)
-                .Include(mc => mc.SmartCollections)
-                .Include(mc => mc.MultiCollectionItems)
-                .ThenInclude(mci => mci.Collection)
-                .Include(mc => mc.MultiCollectionSmartItems)
-                .ThenInclude(mci => mci.SmartCollection)
-                .SelectOneAsync(mc => mc.Id, mc => mc.Id == id);
-
-            foreach (MultiCollection multiCollection in maybeMultiCollection)
+            foreach (MultiCollectionItem multiCollectionItem in multiCollection.MultiCollectionItems)
             {
-                foreach (MultiCollectionItem multiCollectionItem in multiCollection.MultiCollectionItems)
+                List<MediaItem> items = await GetItems(multiCollectionItem.CollectionId);
+
+                if (multiCollectionItem.Collection.UseCustomPlaybackOrder)
                 {
-                    List<MediaItem> items = await GetItems(multiCollectionItem.CollectionId);
-
-                    if (multiCollectionItem.Collection.UseCustomPlaybackOrder)
+                    foreach (Collection collection in await GetCollectionWithCollectionItemsUntracked(
+                                 multiCollectionItem.CollectionId))
                     {
-                        foreach (Collection collection in await GetCollectionWithCollectionItemsUntracked(
-                            multiCollectionItem.CollectionId))
-                        {
-                            var sortedItems = collection.CollectionItems
-                                .OrderBy(ci => ci.CustomIndex)
-                                .Map(ci => items.First(i => i.Id == ci.MediaItemId))
-                                .ToList();
+                        var sortedItems = collection.CollectionItems
+                            .OrderBy(ci => ci.CustomIndex)
+                            .Map(ci => items.First(i => i.Id == ci.MediaItemId))
+                            .ToList();
 
-                            result.Add(
-                                new CollectionWithItems(
-                                    multiCollectionItem.CollectionId,
-                                    sortedItems,
-                                    multiCollectionItem.ScheduleAsGroup,
-                                    multiCollectionItem.PlaybackOrder,
-                                    multiCollectionItem.Collection.UseCustomPlaybackOrder));
-                        }
-                    }
-                    else
-                    {
                         result.Add(
                             new CollectionWithItems(
                                 multiCollectionItem.CollectionId,
-                                items,
+                                sortedItems,
                                 multiCollectionItem.ScheduleAsGroup,
                                 multiCollectionItem.PlaybackOrder,
                                 multiCollectionItem.Collection.UseCustomPlaybackOrder));
                     }
                 }
-
-                foreach (MultiCollectionSmartItem multiCollectionSmartItem in multiCollection.MultiCollectionSmartItems)
+                else
                 {
-                    List<MediaItem> items = await GetSmartCollectionItems(multiCollectionSmartItem.SmartCollectionId);
-
                     result.Add(
                         new CollectionWithItems(
-                            multiCollectionSmartItem.SmartCollectionId,
+                            multiCollectionItem.CollectionId,
                             items,
-                            multiCollectionSmartItem.ScheduleAsGroup,
-                            multiCollectionSmartItem.PlaybackOrder,
-                            false));
+                            multiCollectionItem.ScheduleAsGroup,
+                            multiCollectionItem.PlaybackOrder,
+                            multiCollectionItem.Collection.UseCustomPlaybackOrder));
                 }
             }
 
-            // remove duplicate items from ungrouped collections
-            var toRemoveFrom = result.Filter(c => !c.ScheduleAsGroup).ToList();
-            var toRemove = result.Filter(c => c.ScheduleAsGroup)
-                .SelectMany(c => c.MediaItems.Map(i => i.Id))
-                .Distinct()
-                .ToList();
-
-            foreach (CollectionWithItems collection in toRemoveFrom)
+            foreach (MultiCollectionSmartItem multiCollectionSmartItem in multiCollection.MultiCollectionSmartItems)
             {
-                collection.MediaItems.RemoveAll(mi => toRemove.Contains(mi.Id));
-            }
+                List<MediaItem> items = await GetSmartCollectionItems(multiCollectionSmartItem.SmartCollectionId);
 
-            return result;
+                result.Add(
+                    new CollectionWithItems(
+                        multiCollectionSmartItem.SmartCollectionId,
+                        items,
+                        multiCollectionSmartItem.ScheduleAsGroup,
+                        multiCollectionSmartItem.PlaybackOrder,
+                        false));
+            }
         }
 
-        public async Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(
-            int? collectionId,
-            int? smartCollectionId)
+        // remove duplicate items from ungrouped collections
+        var toRemoveFrom = result.Filter(c => !c.ScheduleAsGroup).ToList();
+        var toRemove = result.Filter(c => c.ScheduleAsGroup)
+            .SelectMany(c => c.MediaItems.Map(i => i.Id))
+            .Distinct()
+            .ToList();
+
+        foreach (CollectionWithItems collection in toRemoveFrom)
         {
-            var items = new List<MediaItem>();
-
-            if (collectionId.HasValue)
-            {
-                items = await GetItems(collectionId.Value);
-            }
-
-            if (smartCollectionId.HasValue)
-            {
-                items = await GetSmartCollectionItems(smartCollectionId.Value);
-            }
-
-            return GroupIntoFakeCollections(items);
+            collection.MediaItems.RemoveAll(mi => toRemove.Contains(mi.Id));
         }
 
-        private static List<CollectionWithItems> GroupIntoFakeCollections(List<MediaItem> items)
+        return result;
+    }
+
+    public async Task<List<CollectionWithItems>> GetFakeMultiCollectionCollections(
+        int? collectionId,
+        int? smartCollectionId)
+    {
+        var items = new List<MediaItem>();
+
+        if (collectionId.HasValue)
         {
-            int id = -1;
-            var result = new List<CollectionWithItems>();
+            items = await GetItems(collectionId.Value);
+        }
 
-            var showCollections = new Dictionary<int, List<MediaItem>>();
-            foreach (Episode episode in items.OfType<Episode>())
+        if (smartCollectionId.HasValue)
+        {
+            items = await GetSmartCollectionItems(smartCollectionId.Value);
+        }
+
+        return GroupIntoFakeCollections(items);
+    }
+
+    private static List<CollectionWithItems> GroupIntoFakeCollections(List<MediaItem> items)
+    {
+        int id = -1;
+        var result = new List<CollectionWithItems>();
+
+        var showCollections = new Dictionary<int, List<MediaItem>>();
+        foreach (Episode episode in items.OfType<Episode>())
+        {
+            List<MediaItem> list = showCollections.ContainsKey(episode.Season.ShowId)
+                ? showCollections[episode.Season.ShowId]
+                : new List<MediaItem>();
+
+            if (list.All(i => i.Id != episode.Id))
             {
-                List<MediaItem> list = showCollections.ContainsKey(episode.Season.ShowId)
-                    ? showCollections[episode.Season.ShowId]
-                    : new List<MediaItem>();
-
-                if (list.All(i => i.Id != episode.Id))
-                {
-                    list.Add(episode);
-                }
-
-                showCollections[episode.Season.ShowId] = list;
+                list.Add(episode);
             }
 
-            foreach ((int _, List<MediaItem> list) in showCollections)
-            {
-                result.Add(
-                    new CollectionWithItems(
-                        id--,
-                        list,
-                        true,
-                        PlaybackOrder.Chronological,
-                        false));
-            }
-            
-            var artistCollections = new Dictionary<int, List<MediaItem>>();
-            foreach (MusicVideo musicVideo in items.OfType<MusicVideo>())
-            {
-                List<MediaItem> list = artistCollections.ContainsKey(musicVideo.ArtistId)
-                    ? artistCollections[musicVideo.ArtistId]
-                    : new List<MediaItem>();
-
-                if (list.All(i => i.Id != musicVideo.Id))
-                {
-                    list.Add(musicVideo);
-                }
-
-                artistCollections[musicVideo.ArtistId] = list;
-            }
-
-            foreach ((int _, List<MediaItem> list) in artistCollections)
-            {
-                result.Add(
-                    new CollectionWithItems(
-                        id--,
-                        list,
-                        true,
-                        PlaybackOrder.Chronological,
-                        false));
-            }
-
-            var allArtists = items.OfType<Song>()
-                .SelectMany(s => s.SongMetadata)
-                .Map(sm => sm.Artist)
-                .Distinct()
-                .ToList();
-
-            if (!allArtists.Contains(string.Empty))
-            {
-                allArtists.Add(string.Empty);
-            }
-
-            var songArtistCollections = new Dictionary<int, List<MediaItem>>();
-            foreach (Song song in items.OfType<Song>())
-            {
-                int key = allArtists.IndexOf(song.SongMetadata.HeadOrNone().Match(sm => sm.Artist, string.Empty));
-                
-                List<MediaItem> list = songArtistCollections.ContainsKey(key)
-                        ? songArtistCollections[key]
-                        : new List<MediaItem>();
-
-                if (list.All(i => i.Id != song.Id))
-                {
-                    list.Add(song);
-                }
-
-                songArtistCollections[key] = list;
-            }
-
-            foreach ((int _, List<MediaItem> list) in songArtistCollections)
-            {
-                result.Add(
-                    new CollectionWithItems(
-                        id--,
-                        list,
-                        true,
-                        PlaybackOrder.Chronological,
-                        false));
-            }
+            showCollections[episode.Season.ShowId] = list;
+        }
 
+        foreach ((int _, List<MediaItem> list) in showCollections)
+        {
             result.Add(
                 new CollectionWithItems(
-                    id,
-                    items.OfType<Movie>().Cast<MediaItem>().ToList(),
+                    id--,
+                    list,
                     true,
                     PlaybackOrder.Chronological,
                     false));
+        }
+            
+        var artistCollections = new Dictionary<int, List<MediaItem>>();
+        foreach (MusicVideo musicVideo in items.OfType<MusicVideo>())
+        {
+            List<MediaItem> list = artistCollections.ContainsKey(musicVideo.ArtistId)
+                ? artistCollections[musicVideo.ArtistId]
+                : new List<MediaItem>();
 
-            return result;
+            if (list.All(i => i.Id != musicVideo.Id))
+            {
+                list.Add(musicVideo);
+            }
+
+            artistCollections[musicVideo.ArtistId] = list;
         }
 
-        public Task<List<int>> PlayoutIdsUsingCollection(int collectionId) =>
-            _dbConnection.QueryAsync<int>(
-                    @"SELECT DISTINCT p.PlayoutId
+        foreach ((int _, List<MediaItem> list) in artistCollections)
+        {
+            result.Add(
+                new CollectionWithItems(
+                    id--,
+                    list,
+                    true,
+                    PlaybackOrder.Chronological,
+                    false));
+        }
+
+        var allArtists = items.OfType<Song>()
+            .SelectMany(s => s.SongMetadata)
+            .Map(sm => sm.Artist)
+            .Distinct()
+            .ToList();
+
+        if (!allArtists.Contains(string.Empty))
+        {
+            allArtists.Add(string.Empty);
+        }
+
+        var songArtistCollections = new Dictionary<int, List<MediaItem>>();
+        foreach (Song song in items.OfType<Song>())
+        {
+            int key = allArtists.IndexOf(song.SongMetadata.HeadOrNone().Match(sm => sm.Artist, string.Empty));
+                
+            List<MediaItem> list = songArtistCollections.ContainsKey(key)
+                ? songArtistCollections[key]
+                : new List<MediaItem>();
+
+            if (list.All(i => i.Id != song.Id))
+            {
+                list.Add(song);
+            }
+
+            songArtistCollections[key] = list;
+        }
+
+        foreach ((int _, List<MediaItem> list) in songArtistCollections)
+        {
+            result.Add(
+                new CollectionWithItems(
+                    id--,
+                    list,
+                    true,
+                    PlaybackOrder.Chronological,
+                    false));
+        }
+
+        result.Add(
+            new CollectionWithItems(
+                id,
+                items.OfType<Movie>().Cast<MediaItem>().ToList(),
+                true,
+                PlaybackOrder.Chronological,
+                false));
+
+        return result;
+    }
+
+    public Task<List<int>> PlayoutIdsUsingCollection(int collectionId) =>
+        _dbConnection.QueryAsync<int>(
+                @"SELECT DISTINCT p.PlayoutId
                     FROM PlayoutProgramScheduleAnchor p
                     WHERE p.CollectionId = @CollectionId",
-                    new { CollectionId = collectionId })
-                .Map(result => result.ToList());
+                new { CollectionId = collectionId })
+            .Map(result => result.ToList());
 
-        public Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId) =>
-            _dbConnection.QueryAsync<int>(
-                    @"SELECT DISTINCT p.PlayoutId
+    public Task<List<int>> PlayoutIdsUsingMultiCollection(int multiCollectionId) =>
+        _dbConnection.QueryAsync<int>(
+                @"SELECT DISTINCT p.PlayoutId
                     FROM PlayoutProgramScheduleAnchor p
                     WHERE p.MultiCollectionId = @MultiCollectionId",
-                    new { MultiCollectionId = multiCollectionId })
-                .Map(result => result.ToList());
+                new { MultiCollectionId = multiCollectionId })
+            .Map(result => result.ToList());
 
-        public Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId) =>
-            _dbConnection.QueryAsync<int>(
-                    @"SELECT DISTINCT p.PlayoutId
+    public Task<List<int>> PlayoutIdsUsingSmartCollection(int smartCollectionId) =>
+        _dbConnection.QueryAsync<int>(
+                @"SELECT DISTINCT p.PlayoutId
                     FROM PlayoutProgramScheduleAnchor p
                     WHERE p.SmartCollectionId = @SmartCollectionId",
-                    new { SmartCollectionId = smartCollectionId })
-                .Map(result => result.ToList());
+                new { SmartCollectionId = smartCollectionId })
+            .Map(result => result.ToList());
 
-        public Task<bool> IsCustomPlaybackOrder(int collectionId) =>
-            _dbConnection.QuerySingleAsync<bool>(
-                @"SELECT IFNULL(MIN(UseCustomPlaybackOrder), 0) FROM Collection WHERE Id = @CollectionId",
-                new { CollectionId = collectionId });
+    public Task<bool> IsCustomPlaybackOrder(int collectionId) =>
+        _dbConnection.QuerySingleAsync<bool>(
+            @"SELECT IFNULL(MIN(UseCustomPlaybackOrder), 0) FROM Collection WHERE Id = @CollectionId",
+            new { CollectionId = collectionId });
 
-        public async Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection)
+    public async Task<Option<string>> GetNameFromKey(CollectionKey emptyCollection)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+
+        return emptyCollection.CollectionType switch
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+            ProgramScheduleItemCollectionType.Artist => await dbContext.Artists.Include(a => a.ArtistMetadata)
+                .SelectOneAsync(a => a.Id, a => a.Id == emptyCollection.MediaItemId.Value)
+                .MapT(a => a.ArtistMetadata.Head().Title),
+            ProgramScheduleItemCollectionType.Collection => await dbContext.Collections
+                .SelectOneAsync(c => c.Id, c => c.Id == emptyCollection.CollectionId.Value)
+                .MapT(c => c.Name),
+            ProgramScheduleItemCollectionType.MultiCollection => await dbContext.MultiCollections
+                .SelectOneAsync(c => c.Id, c => c.Id == emptyCollection.MultiCollectionId.Value)
+                .MapT(c => c.Name),
+            ProgramScheduleItemCollectionType.SmartCollection => await dbContext.SmartCollections
+                .SelectOneAsync(c => c.Id, c => c.Id == emptyCollection.SmartCollectionId.Value)
+                .MapT(c => c.Name),
+            ProgramScheduleItemCollectionType.TelevisionSeason => await dbContext.Seasons
+                .Include(s => s.SeasonMetadata)
+                .Include(s => s.Show)
+                .ThenInclude(s => s.ShowMetadata)
+                .SelectOneAsync(a => a.Id, a => a.Id == emptyCollection.MediaItemId.Value)
+                .MapT(s => $"{s.Show.ShowMetadata.Head().Title} Season {s.SeasonNumber}"),
+            ProgramScheduleItemCollectionType.TelevisionShow => await dbContext.Shows.Include(s => s.ShowMetadata)
+                .SelectOneAsync(a => a.Id, a => a.Id == emptyCollection.MediaItemId.Value)
+                .MapT(s => s.ShowMetadata.Head().Title),
+            _ => None
+        };
+    }
 
-            return emptyCollection.CollectionType switch
-            {
-                ProgramScheduleItemCollectionType.Artist => await dbContext.Artists.Include(a => a.ArtistMetadata)
-                    .SelectOneAsync(a => a.Id, a => a.Id == emptyCollection.MediaItemId.Value)
-                    .MapT(a => a.ArtistMetadata.Head().Title),
-                ProgramScheduleItemCollectionType.Collection => await dbContext.Collections
-                    .SelectOneAsync(c => c.Id, c => c.Id == emptyCollection.CollectionId.Value)
-                    .MapT(c => c.Name),
-                ProgramScheduleItemCollectionType.MultiCollection => await dbContext.MultiCollections
-                    .SelectOneAsync(c => c.Id, c => c.Id == emptyCollection.MultiCollectionId.Value)
-                    .MapT(c => c.Name),
-                ProgramScheduleItemCollectionType.SmartCollection => await dbContext.SmartCollections
-                    .SelectOneAsync(c => c.Id, c => c.Id == emptyCollection.SmartCollectionId.Value)
-                    .MapT(c => c.Name),
-                ProgramScheduleItemCollectionType.TelevisionSeason => await dbContext.Seasons
-                    .Include(s => s.SeasonMetadata)
-                    .Include(s => s.Show)
-                    .ThenInclude(s => s.ShowMetadata)
-                    .SelectOneAsync(a => a.Id, a => a.Id == emptyCollection.MediaItemId.Value)
-                    .MapT(s => $"{s.Show.ShowMetadata.Head().Title} Season {s.SeasonNumber}"),
-                ProgramScheduleItemCollectionType.TelevisionShow => await dbContext.Shows.Include(s => s.ShowMetadata)
-                    .SelectOneAsync(a => a.Id, a => a.Id == emptyCollection.MediaItemId.Value)
-                    .MapT(s => s.ShowMetadata.Head().Title),
-                _ => None
-            };
-        }
-
-        private async Task<List<Movie>> GetMovieItems(TvContext dbContext, int collectionId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM CollectionItem ci
+    private async Task<List<Movie>> GetMovieItems(TvContext dbContext, int collectionId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM CollectionItem ci
             INNER JOIN Movie m ON m.Id = ci.MediaItemId
             WHERE ci.CollectionId = @CollectionId",
-                new { CollectionId = collectionId });
+            new { CollectionId = collectionId });
 
-            return await GetMovieItems(dbContext, ids);
-        }
+        return await GetMovieItems(dbContext, ids);
+    }
         
-        private static Task<List<Movie>> GetMovieItems(TvContext dbContext, IEnumerable<int> movieIds) =>
-            dbContext.Movies
-                .Include(m => m.MovieMetadata)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Filter(m => movieIds.Contains(m.Id))
-                .ToListAsync();
+    private static Task<List<Movie>> GetMovieItems(TvContext dbContext, IEnumerable<int> movieIds) =>
+        dbContext.Movies
+            .Include(m => m.MovieMetadata)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Filter(m => movieIds.Contains(m.Id))
+            .ToListAsync();
 
-        private async Task<List<MusicVideo>> GetArtistItems(TvContext dbContext, int collectionId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT MusicVideo.Id FROM CollectionItem ci
+    private async Task<List<MusicVideo>> GetArtistItems(TvContext dbContext, int collectionId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT MusicVideo.Id FROM CollectionItem ci
             INNER JOIN Artist on Artist.Id = ci.MediaItemId
             INNER JOIN MusicVideo on Artist.Id = MusicVideo.ArtistId
             WHERE ci.CollectionId = @CollectionId",
-                new { CollectionId = collectionId });
+            new { CollectionId = collectionId });
 
-            return await GetArtistItemsFromMusicVideoIds(dbContext, ids);
-        }
+        return await GetArtistItemsFromMusicVideoIds(dbContext, ids);
+    }
 
-        private static Task<List<MusicVideo>> GetArtistItemsFromMusicVideoIds(
-            TvContext dbContext,
-            IEnumerable<int> musicVideoIds) =>
-            dbContext.MusicVideos
-                .Include(m => m.Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .Include(m => m.MusicVideoMetadata)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Filter(m => musicVideoIds.Contains(m.Id))
-                .ToListAsync();
+    private static Task<List<MusicVideo>> GetArtistItemsFromMusicVideoIds(
+        TvContext dbContext,
+        IEnumerable<int> musicVideoIds) =>
+        dbContext.MusicVideos
+            .Include(m => m.Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .Include(m => m.MusicVideoMetadata)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Filter(m => musicVideoIds.Contains(m.Id))
+            .ToListAsync();
         
-        private async Task<List<MusicVideo>> GetArtistItemsFromArtistId(TvContext dbContext, int artistId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT MusicVideo.Id FROM Artist
+    private async Task<List<MusicVideo>> GetArtistItemsFromArtistId(TvContext dbContext, int artistId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT MusicVideo.Id FROM Artist
             INNER JOIN MusicVideo on Artist.Id = MusicVideo.ArtistId
             WHERE Artist.Id = @ArtistId",
-                new { ArtistId = artistId });
+            new { ArtistId = artistId });
 
-            return await GetArtistItemsFromMusicVideoIds(dbContext, ids);
-        }
+        return await GetArtistItemsFromMusicVideoIds(dbContext, ids);
+    }
 
-        private async Task<List<MusicVideo>> GetMusicVideoItems(TvContext dbContext, int collectionId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM CollectionItem ci
+    private async Task<List<MusicVideo>> GetMusicVideoItems(TvContext dbContext, int collectionId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM CollectionItem ci
             INNER JOIN MusicVideo m ON m.Id = ci.MediaItemId
             WHERE ci.CollectionId = @CollectionId",
-                new { CollectionId = collectionId });
+            new { CollectionId = collectionId });
 
-            return await GetMusicVideoItems(dbContext, ids);
-        }
+        return await GetMusicVideoItems(dbContext, ids);
+    }
         
-        private static Task<List<MusicVideo>> GetMusicVideoItems(TvContext dbContext, IEnumerable<int> musicVideoIds) =>
-            dbContext.MusicVideos
-                .Include(m => m.Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .Include(m => m.MusicVideoMetadata)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Filter(m => musicVideoIds.Contains(m.Id))
-                .ToListAsync();
+    private static Task<List<MusicVideo>> GetMusicVideoItems(TvContext dbContext, IEnumerable<int> musicVideoIds) =>
+        dbContext.MusicVideos
+            .Include(m => m.Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .Include(m => m.MusicVideoMetadata)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Filter(m => musicVideoIds.Contains(m.Id))
+            .ToListAsync();
         
-        private async Task<List<OtherVideo>> GetOtherVideoItems(TvContext dbContext, int collectionId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT o.Id FROM CollectionItem ci
+    private async Task<List<OtherVideo>> GetOtherVideoItems(TvContext dbContext, int collectionId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT o.Id FROM CollectionItem ci
             INNER JOIN OtherVideo o ON o.Id = ci.MediaItemId
             WHERE ci.CollectionId = @CollectionId",
-                new { CollectionId = collectionId });
+            new { CollectionId = collectionId });
 
-            return await GetOtherVideoItems(dbContext, ids);
-        }
+        return await GetOtherVideoItems(dbContext, ids);
+    }
 
-        private static Task<List<OtherVideo>> GetOtherVideoItems(TvContext dbContext, IEnumerable<int> otherVideoIds) =>
-            dbContext.OtherVideos
-                .Include(m => m.OtherVideoMetadata)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Filter(m => otherVideoIds.Contains(m.Id))
-                .ToListAsync();
+    private static Task<List<OtherVideo>> GetOtherVideoItems(TvContext dbContext, IEnumerable<int> otherVideoIds) =>
+        dbContext.OtherVideos
+            .Include(m => m.OtherVideoMetadata)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Filter(m => otherVideoIds.Contains(m.Id))
+            .ToListAsync();
 
-        private async Task<List<Song>> GetSongItems(TvContext dbContext, int collectionId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT s.Id FROM CollectionItem ci
+    private async Task<List<Song>> GetSongItems(TvContext dbContext, int collectionId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT s.Id FROM CollectionItem ci
             INNER JOIN Song s ON s.Id = ci.MediaItemId
             WHERE ci.CollectionId = @CollectionId",
-                new { CollectionId = collectionId });
+            new { CollectionId = collectionId });
 
-            return await GetSongItems(dbContext, ids);
-        }
+        return await GetSongItems(dbContext, ids);
+    }
 
-        private static Task<List<Song>> GetSongItems(TvContext dbContext, IEnumerable<int> songIds) =>
-            dbContext.Songs
-                .Include(m => m.SongMetadata)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Filter(m => songIds.Contains(m.Id))
-                .ToListAsync();
+    private static Task<List<Song>> GetSongItems(TvContext dbContext, IEnumerable<int> songIds) =>
+        dbContext.Songs
+            .Include(m => m.SongMetadata)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Filter(m => songIds.Contains(m.Id))
+            .ToListAsync();
 
-        private async Task<List<Episode>> GetShowItems(TvContext dbContext, int collectionId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT Episode.Id FROM CollectionItem ci
+    private async Task<List<Episode>> GetShowItems(TvContext dbContext, int collectionId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT Episode.Id FROM CollectionItem ci
             INNER JOIN Show ON Show.Id = ci.MediaItemId
             INNER JOIN Season ON Season.ShowId = Show.Id
             INNER JOIN Episode ON Episode.SeasonId = Season.Id
             WHERE ci.CollectionId = @CollectionId",
-                new { CollectionId = collectionId });
+            new { CollectionId = collectionId });
 
-            return await GetShowItemsFromEpisodeIds(dbContext, ids);
-        }
+        return await GetShowItemsFromEpisodeIds(dbContext, ids);
+    }
         
-        private static Task<List<Episode>> GetShowItemsFromEpisodeIds(TvContext dbContext, IEnumerable<int> episodeIds) =>
-            dbContext.Episodes
-                .Include(e => e.EpisodeMetadata)
-                .Include(e => e.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(e => e.Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Filter(e => episodeIds.Contains(e.Id))
-                .ToListAsync();
+    private static Task<List<Episode>> GetShowItemsFromEpisodeIds(TvContext dbContext, IEnumerable<int> episodeIds) =>
+        dbContext.Episodes
+            .Include(e => e.EpisodeMetadata)
+            .Include(e => e.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(e => e.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Filter(e => episodeIds.Contains(e.Id))
+            .ToListAsync();
 
-        private async Task<List<Episode>> GetShowItemsFromShowId(TvContext dbContext, int showId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT Episode.Id FROM Show
+    private async Task<List<Episode>> GetShowItemsFromShowId(TvContext dbContext, int showId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT Episode.Id FROM Show
             INNER JOIN Season ON Season.ShowId = Show.Id
             INNER JOIN Episode ON Episode.SeasonId = Season.Id
             WHERE Show.Id = @ShowId",
-                new { ShowId = showId });
+            new { ShowId = showId });
 
-            return await GetShowItemsFromEpisodeIds(dbContext, ids);
-        }
+        return await GetShowItemsFromEpisodeIds(dbContext, ids);
+    }
 
-        private async Task<List<Episode>> GetSeasonItems(TvContext dbContext, int collectionId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT Episode.Id FROM CollectionItem ci
+    private async Task<List<Episode>> GetSeasonItems(TvContext dbContext, int collectionId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT Episode.Id FROM CollectionItem ci
             INNER JOIN Season ON Season.Id = ci.MediaItemId
             INNER JOIN Episode ON Episode.SeasonId = Season.Id
             WHERE ci.CollectionId = @CollectionId",
-                new { CollectionId = collectionId });
+            new { CollectionId = collectionId });
 
-            return await GetSeasonItemsFromEpisodeIds(dbContext, ids);
-        }
+        return await GetSeasonItemsFromEpisodeIds(dbContext, ids);
+    }
         
-        private static Task<List<Episode>> GetSeasonItemsFromEpisodeIds(TvContext dbContext, IEnumerable<int> episodeIds) =>
-            dbContext.Episodes
-                .Include(e => e.EpisodeMetadata)
-                .Include(e => e.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(e => e.Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Filter(e => episodeIds.Contains(e.Id))
-                .ToListAsync();
+    private static Task<List<Episode>> GetSeasonItemsFromEpisodeIds(TvContext dbContext, IEnumerable<int> episodeIds) =>
+        dbContext.Episodes
+            .Include(e => e.EpisodeMetadata)
+            .Include(e => e.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(e => e.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Filter(e => episodeIds.Contains(e.Id))
+            .ToListAsync();
         
-        private async Task<List<Episode>> GetSeasonItemsFromSeasonId(TvContext dbContext, int seasonId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT Episode.Id FROM Season
+    private async Task<List<Episode>> GetSeasonItemsFromSeasonId(TvContext dbContext, int seasonId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT Episode.Id FROM Season
             INNER JOIN Episode ON Episode.SeasonId = Season.Id
             WHERE Season.Id = @SeasonId",
-                new { SeasonId = seasonId });
+            new { SeasonId = seasonId });
 
-            return await GetSeasonItemsFromEpisodeIds(dbContext, ids);
-        }
+        return await GetSeasonItemsFromEpisodeIds(dbContext, ids);
+    }
 
-        private async Task<List<Episode>> GetEpisodeItems(TvContext dbContext, int collectionId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT Episode.Id FROM CollectionItem ci
+    private async Task<List<Episode>> GetEpisodeItems(TvContext dbContext, int collectionId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT Episode.Id FROM CollectionItem ci
             INNER JOIN Episode ON Episode.Id = ci.MediaItemId
             WHERE ci.CollectionId = @CollectionId",
-                new { CollectionId = collectionId });
+            new { CollectionId = collectionId });
 
-            return await GetEpisodeItems(dbContext, ids);
-        }
-        
-        private static Task<List<Episode>> GetEpisodeItems(TvContext dbContext, IEnumerable<int> episodeIds) =>
-            dbContext.Episodes
-                .Include(e => e.EpisodeMetadata)
-                .Include(e => e.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(e => e.Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Filter(e => episodeIds.Contains(e.Id))
-                .ToListAsync();
+        return await GetEpisodeItems(dbContext, ids);
     }
-}
+        
+    private static Task<List<Episode>> GetEpisodeItems(TvContext dbContext, IEnumerable<int> episodeIds) =>
+        dbContext.Episodes
+            .Include(e => e.EpisodeMetadata)
+            .Include(e => e.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(e => e.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Filter(e => episodeIds.Contains(e.Id))
+            .ToListAsync();
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/MediaItemRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/MediaItemRepository.cs
index 5cdcfcb10..b04b4f27f 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/MediaItemRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/MediaItemRepository.cs
@@ -1,69 +1,64 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class MediaItemRepository : IMediaItemRepository
 {
-    public class MediaItemRepository : IMediaItemRepository
-    {
-        private readonly IDbConnection _dbConnection;
+    private readonly IDbConnection _dbConnection;
 
-        public MediaItemRepository(IDbConnection dbConnection) => _dbConnection = dbConnection;
+    public MediaItemRepository(IDbConnection dbConnection) => _dbConnection = dbConnection;
 
-        public Task<List<string>> GetAllLanguageCodes() =>
-            _dbConnection.QueryAsync<string>(
-                    @"SELECT LanguageCode FROM
+    public Task<List<string>> GetAllLanguageCodes() =>
+        _dbConnection.QueryAsync<string>(
+                @"SELECT LanguageCode FROM
                     (SELECT Language AS LanguageCode
                     FROM MediaStream WHERE Language IS NOT NULL
                     UNION ALL SELECT PreferredLanguageCode AS LanguageCode
                     FROM Channel WHERE PreferredLanguageCode IS NOT NULL)
                     GROUP BY LanguageCode
                     ORDER BY COUNT(LanguageCode) DESC")
-                .Map(result => result.ToList());
+            .Map(result => result.ToList());
 
-        public async Task<List<int>> FlagFileNotFound(LibraryPath libraryPath, string path)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                    @"SELECT M.Id
+    public async Task<List<int>> FlagFileNotFound(LibraryPath libraryPath, string path)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+                @"SELECT M.Id
                 FROM MediaItem M
                 INNER JOIN MediaVersion MV on M.Id = COALESCE(MovieId, MusicVideoId, OtherVideoId, SongId, EpisodeId)
                 INNER JOIN MediaFile MF on MV.Id = MF.MediaVersionId
                 WHERE M.LibraryPathId = @LibraryPathId AND MF.Path = @Path",
-                    new { LibraryPathId = libraryPath.Id, Path = path })
-                .Map(result => result.ToList());
+                new { LibraryPathId = libraryPath.Id, Path = path })
+            .Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"UPDATE MediaItem SET State = 1 WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            @"UPDATE MediaItem SET State = 1 WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
-        }
-
-        public async Task<Unit> FlagNormal(MediaItem mediaItem)
-        {
-            mediaItem.State = MediaItemState.Normal;
-            
-            return await _dbConnection.ExecuteAsync(
-                @"UPDATE MediaItem SET State = 0 WHERE Id = @Id",
-                new { mediaItem.Id }).ToUnit();
-        }
-
-        public async Task<Either<BaseError, Unit>> DeleteItems(List<int> mediaItemIds)
-        {
-            foreach (int mediaItemId in mediaItemIds)
-            {
-                await _dbConnection.ExecuteAsync(
-                    "DELETE FROM MediaItem WHERE Id = @Id",
-                    new { Id = mediaItemId });
-            }
-
-            return Unit.Default;
-        }
+        return ids;
     }
-}
+
+    public async Task<Unit> FlagNormal(MediaItem mediaItem)
+    {
+        mediaItem.State = MediaItemState.Normal;
+            
+        return await _dbConnection.ExecuteAsync(
+            @"UPDATE MediaItem SET State = 0 WHERE Id = @Id",
+            new { mediaItem.Id }).ToUnit();
+    }
+
+    public async Task<Either<BaseError, Unit>> DeleteItems(List<int> mediaItemIds)
+    {
+        foreach (int mediaItemId in mediaItemIds)
+        {
+            await _dbConnection.ExecuteAsync(
+                "DELETE FROM MediaItem WHERE Id = @Id",
+                new { Id = mediaItemId });
+        }
+
+        return Unit.Default;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs
index 0218dbab4..09623b484 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/MediaSourceRepository.cs
@@ -1,959 +1,953 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class MediaSourceRepository : IMediaSourceRepository
 {
-    public class MediaSourceRepository : IMediaSourceRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public MediaSourceRepository(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public MediaSourceRepository(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<PlexMediaSource> Add(PlexMediaSource plexMediaSource)
+    {
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+        await context.PlexMediaSources.AddAsync(plexMediaSource);
+        await context.SaveChangesAsync();
+        return plexMediaSource;
+    }
 
-        public async Task<PlexMediaSource> Add(PlexMediaSource plexMediaSource)
-        {
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            await context.PlexMediaSources.AddAsync(plexMediaSource);
-            await context.SaveChangesAsync();
-            return plexMediaSource;
-        }
+    public Task<List<PlexMediaSource>> GetAllPlex()
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.PlexMediaSources
+            .Include(p => p.Connections)
+            .ToListAsync();
+    }
 
-        public Task<List<PlexMediaSource>> GetAllPlex()
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.PlexMediaSources
-                .Include(p => p.Connections)
-                .ToListAsync();
-        }
+    public Task<List<PlexLibrary>> GetPlexLibraries(int plexMediaSourceId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.PlexLibraries
+            .Filter(l => l.MediaSourceId == plexMediaSourceId)
+            .ToListAsync();
+    }
 
-        public Task<List<PlexLibrary>> GetPlexLibraries(int plexMediaSourceId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.PlexLibraries
-                .Filter(l => l.MediaSourceId == plexMediaSourceId)
-                .ToListAsync();
-        }
+    public Task<List<PlexPathReplacement>> GetPlexPathReplacements(int plexMediaSourceId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.PlexPathReplacements
+            .Include(ppr => ppr.PlexMediaSource)
+            .Filter(r => r.PlexMediaSourceId == plexMediaSourceId)
+            .ToListAsync();
+    }
 
-        public Task<List<PlexPathReplacement>> GetPlexPathReplacements(int plexMediaSourceId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.PlexPathReplacements
-                .Include(ppr => ppr.PlexMediaSource)
-                .Filter(r => r.PlexMediaSourceId == plexMediaSourceId)
-                .ToListAsync();
-        }
+    public Task<Option<PlexLibrary>> GetPlexLibrary(int plexLibraryId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.PlexLibraries
+            .Include(l => l.Paths)
+            .OrderBy(l => l.Id) // https://github.com/dotnet/efcore/issues/22579
+            .SingleOrDefaultAsync(l => l.Id == plexLibraryId)
+            .Map(Optional);
+    }
 
-        public Task<Option<PlexLibrary>> GetPlexLibrary(int plexLibraryId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.PlexLibraries
-                .Include(l => l.Paths)
-                .OrderBy(l => l.Id) // https://github.com/dotnet/efcore/issues/22579
-                .SingleOrDefaultAsync(l => l.Id == plexLibraryId)
-                .Map(Optional);
-        }
+    public Task<Option<PlexMediaSource>> GetPlex(int id)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.PlexMediaSources
+            .Include(p => p.Connections)
+            .Include(p => p.Libraries)
+            .Include(p => p.PathReplacements)
+            .OrderBy(s => s.Id) // https://github.com/dotnet/efcore/issues/22579
+            .SingleOrDefaultAsync(p => p.Id == id)
+            .Map(Optional);
+    }
 
-        public Task<Option<PlexMediaSource>> GetPlex(int id)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.PlexMediaSources
-                .Include(p => p.Connections)
-                .Include(p => p.Libraries)
-                .Include(p => p.PathReplacements)
-                .OrderBy(s => s.Id) // https://github.com/dotnet/efcore/issues/22579
-                .SingleOrDefaultAsync(p => p.Id == id)
-                .Map(Optional);
-        }
-
-        public async Task<Option<PlexMediaSource>> GetPlexByLibraryId(int plexLibraryId)
-        {
-            int? id = await _dbConnection.QuerySingleOrDefaultAsync<int?>(
-                @"SELECT L.MediaSourceId FROM Library L
+    public async Task<Option<PlexMediaSource>> GetPlexByLibraryId(int plexLibraryId)
+    {
+        int? id = await _dbConnection.QuerySingleOrDefaultAsync<int?>(
+            @"SELECT L.MediaSourceId FROM Library L
                 INNER JOIN PlexLibrary PL on L.Id = PL.Id
                 WHERE L.Id = @PlexLibraryId",
-                new { PlexLibraryId = plexLibraryId });
+            new { PlexLibraryId = plexLibraryId });
 
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            return await context.PlexMediaSources
-                .Include(p => p.Connections)
-                .Include(p => p.Libraries)
-                .OrderBy(p => p.Id)
-                .SingleOrDefaultAsync(p => p.Id == id)
-                .Map(Optional);
-        }
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+        return await context.PlexMediaSources
+            .Include(p => p.Connections)
+            .Include(p => p.Libraries)
+            .OrderBy(p => p.Id)
+            .SingleOrDefaultAsync(p => p.Id == id)
+            .Map(Optional);
+    }
 
-        public Task<List<PlexPathReplacement>> GetPlexPathReplacementsByLibraryId(int plexLibraryPathId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.PlexPathReplacements
-                .FromSqlRaw(
-                    @"select ppr.* from LibraryPath lp
+    public Task<List<PlexPathReplacement>> GetPlexPathReplacementsByLibraryId(int plexLibraryPathId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.PlexPathReplacements
+            .FromSqlRaw(
+                @"select ppr.* from LibraryPath lp
                     inner join PlexLibrary pl ON pl.Id = lp.LibraryId
                     inner join Library l ON l.Id = pl.Id
                     inner join PlexPathReplacement ppr on ppr.PlexMediaSourceId = l.MediaSourceId
                     where lp.Id = {0}",
-                    plexLibraryPathId)
-                .Include(ppr => ppr.PlexMediaSource)
-                .ToListAsync();
+                plexLibraryPathId)
+            .Include(ppr => ppr.PlexMediaSource)
+            .ToListAsync();
+    }
+
+    public async Task Update(
+        PlexMediaSource plexMediaSource,
+        List<PlexConnection> toAdd,
+        List<PlexConnection> toDelete)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        dbContext.Entry(plexMediaSource).State = EntityState.Modified;
+
+        if (toAdd.Any() || toDelete.Any())
+        {
+            plexMediaSource.Connections.Clear();
+            await dbContext.Entry(plexMediaSource).Collection(pms => pms.Connections).LoadAsync();
+
+            plexMediaSource.Connections.AddRange(toAdd);
+            plexMediaSource.Connections.RemoveAll(toDelete.Contains);
+        }
+        else
+        {
+            foreach (PlexConnection connection in plexMediaSource.Connections)
+            {
+                dbContext.Entry(connection).State = EntityState.Modified;
+            }
         }
 
-        public async Task Update(
-            PlexMediaSource plexMediaSource,
-            List<PlexConnection> toAdd,
-            List<PlexConnection> toDelete)
+        await dbContext.SaveChangesAsync();
+    }
+
+    public async Task<List<int>> UpdateLibraries(
+        int plexMediaSourceId,
+        List<PlexLibrary> toAdd,
+        List<PlexLibrary> toDelete)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        foreach (PlexLibrary add in toAdd)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            dbContext.Entry(plexMediaSource).State = EntityState.Modified;
-
-            if (toAdd.Any() || toDelete.Any())
+            add.MediaSourceId = plexMediaSourceId;
+            dbContext.Entry(add).State = EntityState.Added;
+            foreach (LibraryPath path in add.Paths)
             {
-                plexMediaSource.Connections.Clear();
-                await dbContext.Entry(plexMediaSource).Collection(pms => pms.Connections).LoadAsync();
-
-                plexMediaSource.Connections.AddRange(toAdd);
-                plexMediaSource.Connections.RemoveAll(toDelete.Contains);
+                dbContext.Entry(path).State = EntityState.Added;
             }
-            else
-            {
-                foreach (PlexConnection connection in plexMediaSource.Connections)
-                {
-                    dbContext.Entry(connection).State = EntityState.Modified;
-                }
-            }
-
-            await dbContext.SaveChangesAsync();
         }
 
-        public async Task<List<int>> UpdateLibraries(
-            int plexMediaSourceId,
-            List<PlexLibrary> toAdd,
-            List<PlexLibrary> toDelete)
+        foreach (PlexLibrary delete in toDelete)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            foreach (PlexLibrary add in toAdd)
-            {
-                add.MediaSourceId = plexMediaSourceId;
-                dbContext.Entry(add).State = EntityState.Added;
-                foreach (LibraryPath path in add.Paths)
-                {
-                    dbContext.Entry(path).State = EntityState.Added;
-                }
-            }
-
-            foreach (PlexLibrary delete in toDelete)
-            {
-                dbContext.Entry(delete).State = EntityState.Deleted;
-            }
-
-            List<int> ids = await DisablePlexLibrarySync(toDelete.Map(l => l.Id).ToList());
-
-            await dbContext.SaveChangesAsync();
-
-            return ids;
+            dbContext.Entry(delete).State = EntityState.Deleted;
         }
 
-        public async Task<List<int>> UpdateLibraries(
-            int jellyfinMediaSourceId,
-            List<JellyfinLibrary> toAdd,
-            List<JellyfinLibrary> toDelete)
+        List<int> ids = await DisablePlexLibrarySync(toDelete.Map(l => l.Id).ToList());
+
+        await dbContext.SaveChangesAsync();
+
+        return ids;
+    }
+
+    public async Task<List<int>> UpdateLibraries(
+        int jellyfinMediaSourceId,
+        List<JellyfinLibrary> toAdd,
+        List<JellyfinLibrary> toDelete)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        foreach (JellyfinLibrary add in toAdd)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            foreach (JellyfinLibrary add in toAdd)
+            add.MediaSourceId = jellyfinMediaSourceId;
+            dbContext.Entry(add).State = EntityState.Added;
+            foreach (LibraryPath path in add.Paths)
             {
-                add.MediaSourceId = jellyfinMediaSourceId;
-                dbContext.Entry(add).State = EntityState.Added;
-                foreach (LibraryPath path in add.Paths)
-                {
-                    dbContext.Entry(path).State = EntityState.Added;
-                }
+                dbContext.Entry(path).State = EntityState.Added;
             }
-
-            foreach (JellyfinLibrary delete in toDelete)
-            {
-                dbContext.Entry(delete).State = EntityState.Deleted;
-            }
-
-            List<int> ids = await DisableJellyfinLibrarySync(toDelete.Map(l => l.Id).ToList());
-
-            await dbContext.SaveChangesAsync();
-
-            return ids;
         }
 
-        public async Task<List<int>> UpdateLibraries(
-            int embyMediaSourceId,
-            List<EmbyLibrary> toAdd,
-            List<EmbyLibrary> toDelete)
+        foreach (JellyfinLibrary delete in toDelete)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            foreach (EmbyLibrary add in toAdd)
-            {
-                add.MediaSourceId = embyMediaSourceId;
-                dbContext.Entry(add).State = EntityState.Added;
-                foreach (LibraryPath path in add.Paths)
-                {
-                    dbContext.Entry(path).State = EntityState.Added;
-                }
-            }
-
-            foreach (EmbyLibrary delete in toDelete)
-            {
-                dbContext.Entry(delete).State = EntityState.Deleted;
-            }
-
-            List<int> ids = await DisableEmbyLibrarySync(toDelete.Map(l => l.Id).ToList());
-
-            await dbContext.SaveChangesAsync();
-
-            return ids;
+            dbContext.Entry(delete).State = EntityState.Deleted;
         }
 
-        public async Task<Unit> UpdatePathReplacements(
-            int plexMediaSourceId,
-            List<PlexPathReplacement> toAdd,
-            List<PlexPathReplacement> toUpdate,
-            List<PlexPathReplacement> toDelete)
+        List<int> ids = await DisableJellyfinLibrarySync(toDelete.Map(l => l.Id).ToList());
+
+        await dbContext.SaveChangesAsync();
+
+        return ids;
+    }
+
+    public async Task<List<int>> UpdateLibraries(
+        int embyMediaSourceId,
+        List<EmbyLibrary> toAdd,
+        List<EmbyLibrary> toDelete)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        foreach (EmbyLibrary add in toAdd)
         {
-            foreach (PlexPathReplacement add in toAdd)
+            add.MediaSourceId = embyMediaSourceId;
+            dbContext.Entry(add).State = EntityState.Added;
+            foreach (LibraryPath path in add.Paths)
             {
-                await _dbConnection.ExecuteAsync(
-                    @"INSERT INTO PlexPathReplacement
+                dbContext.Entry(path).State = EntityState.Added;
+            }
+        }
+
+        foreach (EmbyLibrary delete in toDelete)
+        {
+            dbContext.Entry(delete).State = EntityState.Deleted;
+        }
+
+        List<int> ids = await DisableEmbyLibrarySync(toDelete.Map(l => l.Id).ToList());
+
+        await dbContext.SaveChangesAsync();
+
+        return ids;
+    }
+
+    public async Task<Unit> UpdatePathReplacements(
+        int plexMediaSourceId,
+        List<PlexPathReplacement> toAdd,
+        List<PlexPathReplacement> toUpdate,
+        List<PlexPathReplacement> toDelete)
+    {
+        foreach (PlexPathReplacement add in toAdd)
+        {
+            await _dbConnection.ExecuteAsync(
+                @"INSERT INTO PlexPathReplacement
                     (PlexPath, LocalPath, PlexMediaSourceId)
                     VALUES (@PlexPath, @LocalPath, @PlexMediaSourceId)",
-                    new { add.PlexPath, add.LocalPath, PlexMediaSourceId = plexMediaSourceId });
-            }
+                new { add.PlexPath, add.LocalPath, PlexMediaSourceId = plexMediaSourceId });
+        }
 
-            foreach (PlexPathReplacement update in toUpdate)
-            {
-                await _dbConnection.ExecuteAsync(
-                    @"UPDATE PlexPathReplacement
+        foreach (PlexPathReplacement update in toUpdate)
+        {
+            await _dbConnection.ExecuteAsync(
+                @"UPDATE PlexPathReplacement
                     SET PlexPath = @PlexPath, LocalPath = @LocalPath
                     WHERE Id = @Id",
-                    new { update.PlexPath, update.LocalPath, update.Id });
-            }
-
-            foreach (PlexPathReplacement delete in toDelete)
-            {
-                await _dbConnection.ExecuteAsync(
-                    @"DELETE FROM PlexPathReplacement WHERE Id = @Id",
-                    new { delete.Id });
-            }
-
-            return Unit.Default;
+                new { update.PlexPath, update.LocalPath, update.Id });
         }
 
-        public async Task<List<int>> DeleteAllPlex()
+        foreach (PlexPathReplacement delete in toDelete)
         {
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-
-            List<PlexMediaSource> allMediaSources = await context.PlexMediaSources.ToListAsync();
-            context.PlexMediaSources.RemoveRange(allMediaSources);
-
-            List<PlexLibrary> allPlexLibraries = await context.PlexLibraries.ToListAsync();
-            context.PlexLibraries.RemoveRange(allPlexLibraries);
-
-            List<int> movieIds = await context.PlexMovies.Map(pm => pm.Id).ToListAsync();
-            List<int> showIds = await context.PlexShows.Map(ps => ps.Id).ToListAsync();
-            List<int> episodeIds = await context.PlexEpisodes.Map(pe => pe.Id).ToListAsync();
-
-            await context.SaveChangesAsync();
-
-            return movieIds.Append(showIds).Append(episodeIds).ToList();
+            await _dbConnection.ExecuteAsync(
+                @"DELETE FROM PlexPathReplacement WHERE Id = @Id",
+                new { delete.Id });
         }
 
-        public async Task<List<int>> DeletePlex(PlexMediaSource plexMediaSource)
-        {
-            List<int> mediaItemIds = await _dbConnection.QueryAsync<int>(
-                    @"SELECT MediaItem.Id FROM MediaItem
+        return Unit.Default;
+    }
+
+    public async Task<List<int>> DeleteAllPlex()
+    {
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+
+        List<PlexMediaSource> allMediaSources = await context.PlexMediaSources.ToListAsync();
+        context.PlexMediaSources.RemoveRange(allMediaSources);
+
+        List<PlexLibrary> allPlexLibraries = await context.PlexLibraries.ToListAsync();
+        context.PlexLibraries.RemoveRange(allPlexLibraries);
+
+        List<int> movieIds = await context.PlexMovies.Map(pm => pm.Id).ToListAsync();
+        List<int> showIds = await context.PlexShows.Map(ps => ps.Id).ToListAsync();
+        List<int> episodeIds = await context.PlexEpisodes.Map(pe => pe.Id).ToListAsync();
+
+        await context.SaveChangesAsync();
+
+        return movieIds.Append(showIds).Append(episodeIds).ToList();
+    }
+
+    public async Task<List<int>> DeletePlex(PlexMediaSource plexMediaSource)
+    {
+        List<int> mediaItemIds = await _dbConnection.QueryAsync<int>(
+                @"SELECT MediaItem.Id FROM MediaItem
                   INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
                   INNER JOIN Library L on LP.LibraryId = L.Id
                   WHERE L.MediaSourceId = @PlexMediaSourceId",
-                    new { PlexMediaSourceId = plexMediaSource.Id })
-                .Map(result => result.ToList());
+                new { PlexMediaSourceId = plexMediaSource.Id })
+            .Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaSource WHERE Id = @PlexMediaSourceId",
-                new { PlexMediaSourceId = plexMediaSource.Id });
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaSource WHERE Id = @PlexMediaSourceId",
+            new { PlexMediaSourceId = plexMediaSource.Id });
 
-            return mediaItemIds;
-        }
+        return mediaItemIds;
+    }
 
-        public async Task<List<int>> DisablePlexLibrarySync(List<int> libraryIds)
-        {
-            await _dbConnection.ExecuteAsync(
-                "UPDATE PlexLibrary SET ShouldSyncItems = 0 WHERE Id IN @ids",
-                new { ids = libraryIds });
+    public async Task<List<int>> DisablePlexLibrarySync(List<int> libraryIds)
+    {
+        await _dbConnection.ExecuteAsync(
+            "UPDATE PlexLibrary SET ShouldSyncItems = 0 WHERE Id IN @ids",
+            new { ids = libraryIds });
 
-            await _dbConnection.ExecuteAsync(
-                "UPDATE Library SET LastScan = null WHERE Id IN @ids",
-                new { ids = libraryIds });
+        await _dbConnection.ExecuteAsync(
+            "UPDATE Library SET LastScan = null WHERE Id IN @ids",
+            new { ids = libraryIds });
 
-            List<int> movieIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> movieIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexMovie pm ON pm.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexMovie pm ON pm.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> episodeIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> episodeIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexEpisode pe ON pe.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexEpisode pe ON pe.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> seasonIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> seasonIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexSeason ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexSeason ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> showIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> showIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexShow ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexShow ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            return movieIds.Append(showIds).Append(seasonIds).Append(episodeIds).ToList();
-        }
+        return movieIds.Append(showIds).Append(seasonIds).Append(episodeIds).ToList();
+    }
 
-        public Task EnablePlexLibrarySync(IEnumerable<int> libraryIds) =>
-            _dbConnection.ExecuteAsync(
-                "UPDATE PlexLibrary SET ShouldSyncItems = 1 WHERE Id IN @ids",
-                new { ids = libraryIds });
+    public Task EnablePlexLibrarySync(IEnumerable<int> libraryIds) =>
+        _dbConnection.ExecuteAsync(
+            "UPDATE PlexLibrary SET ShouldSyncItems = 1 WHERE Id IN @ids",
+            new { ids = libraryIds });
 
-        public async Task<Unit> UpsertJellyfin(string address, string serverName, string operatingSystem)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<JellyfinMediaSource> maybeExisting = dbContext.JellyfinMediaSources
-                .Include(ms => ms.Connections)
-                .OrderBy(ms => ms.Id)
-                .HeadOrNone();
+    public async Task<Unit> UpsertJellyfin(string address, string serverName, string operatingSystem)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<JellyfinMediaSource> maybeExisting = dbContext.JellyfinMediaSources
+            .Include(ms => ms.Connections)
+            .OrderBy(ms => ms.Id)
+            .HeadOrNone();
 
-            return await maybeExisting.Match(
-                async jellyfinMediaSource =>
+        return await maybeExisting.Match(
+            async jellyfinMediaSource =>
+            {
+                if (!jellyfinMediaSource.Connections.Any())
                 {
-                    if (!jellyfinMediaSource.Connections.Any())
-                    {
-                        jellyfinMediaSource.Connections.Add(new JellyfinConnection { Address = address });
-                    }
-                    else if (jellyfinMediaSource.Connections.Head().Address != address)
-                    {
-                        jellyfinMediaSource.Connections.Head().Address = address;
-                    }
-
-                    if (jellyfinMediaSource.ServerName != serverName)
-                    {
-                        jellyfinMediaSource.ServerName = serverName;
-                    }
-
-                    if (jellyfinMediaSource.OperatingSystem != operatingSystem)
-                    {
-                        jellyfinMediaSource.OperatingSystem = operatingSystem;
-                    }
-
-                    await dbContext.SaveChangesAsync();
-
-                    return Unit.Default;
-                },
-                async () =>
+                    jellyfinMediaSource.Connections.Add(new JellyfinConnection { Address = address });
+                }
+                else if (jellyfinMediaSource.Connections.Head().Address != address)
                 {
-                    var mediaSource = new JellyfinMediaSource
+                    jellyfinMediaSource.Connections.Head().Address = address;
+                }
+
+                if (jellyfinMediaSource.ServerName != serverName)
+                {
+                    jellyfinMediaSource.ServerName = serverName;
+                }
+
+                if (jellyfinMediaSource.OperatingSystem != operatingSystem)
+                {
+                    jellyfinMediaSource.OperatingSystem = operatingSystem;
+                }
+
+                await dbContext.SaveChangesAsync();
+
+                return Unit.Default;
+            },
+            async () =>
+            {
+                var mediaSource = new JellyfinMediaSource
+                {
+                    ServerName = serverName,
+                    OperatingSystem = operatingSystem,
+                    Connections = new List<JellyfinConnection>
                     {
-                        ServerName = serverName,
-                        OperatingSystem = operatingSystem,
-                        Connections = new List<JellyfinConnection>
-                        {
-                            new() { Address = address }
-                        },
-                        PathReplacements = new List<JellyfinPathReplacement>()
-                    };
+                        new() { Address = address }
+                    },
+                    PathReplacements = new List<JellyfinPathReplacement>()
+                };
 
-                    await dbContext.AddAsync(mediaSource);
-                    await dbContext.SaveChangesAsync();
+                await dbContext.AddAsync(mediaSource);
+                await dbContext.SaveChangesAsync();
 
-                    return Unit.Default;
-                });
-        }
+                return Unit.Default;
+            });
+    }
 
-        public Task<List<JellyfinMediaSource>> GetAllJellyfin()
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.JellyfinMediaSources
-                .Include(p => p.Connections)
-                .ToListAsync();
-        }
+    public Task<List<JellyfinMediaSource>> GetAllJellyfin()
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.JellyfinMediaSources
+            .Include(p => p.Connections)
+            .ToListAsync();
+    }
 
-        public Task<Option<JellyfinMediaSource>> GetJellyfin(int id)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.JellyfinMediaSources
-                .Include(p => p.Connections)
-                .Include(p => p.Libraries)
-                .Include(p => p.PathReplacements)
-                .OrderBy(s => s.Id) // https://github.com/dotnet/efcore/issues/22579
-                .SingleOrDefaultAsync(p => p.Id == id)
-                .Map(Optional);
-        }
+    public Task<Option<JellyfinMediaSource>> GetJellyfin(int id)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.JellyfinMediaSources
+            .Include(p => p.Connections)
+            .Include(p => p.Libraries)
+            .Include(p => p.PathReplacements)
+            .OrderBy(s => s.Id) // https://github.com/dotnet/efcore/issues/22579
+            .SingleOrDefaultAsync(p => p.Id == id)
+            .Map(Optional);
+    }
 
-        public Task<List<JellyfinLibrary>> GetJellyfinLibraries(int jellyfinMediaSourceId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.JellyfinLibraries
-                .Filter(l => l.MediaSourceId == jellyfinMediaSourceId)
-                .ToListAsync();
-        }
+    public Task<List<JellyfinLibrary>> GetJellyfinLibraries(int jellyfinMediaSourceId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.JellyfinLibraries
+            .Filter(l => l.MediaSourceId == jellyfinMediaSourceId)
+            .ToListAsync();
+    }
 
-        public Task<Unit> EnableJellyfinLibrarySync(IEnumerable<int> libraryIds) =>
-            _dbConnection.ExecuteAsync(
-                "UPDATE JellyfinLibrary SET ShouldSyncItems = 1 WHERE Id IN @ids",
-                new { ids = libraryIds }).Map(_ => Unit.Default);
+    public Task<Unit> EnableJellyfinLibrarySync(IEnumerable<int> libraryIds) =>
+        _dbConnection.ExecuteAsync(
+            "UPDATE JellyfinLibrary SET ShouldSyncItems = 1 WHERE Id IN @ids",
+            new { ids = libraryIds }).Map(_ => Unit.Default);
 
-        public async Task<List<int>> DisableJellyfinLibrarySync(List<int> libraryIds)
-        {
-            await _dbConnection.ExecuteAsync(
-                "UPDATE JellyfinLibrary SET ShouldSyncItems = 0 WHERE Id IN @ids",
-                new { ids = libraryIds });
+    public async Task<List<int>> DisableJellyfinLibrarySync(List<int> libraryIds)
+    {
+        await _dbConnection.ExecuteAsync(
+            "UPDATE JellyfinLibrary SET ShouldSyncItems = 0 WHERE Id IN @ids",
+            new { ids = libraryIds });
 
-            await _dbConnection.ExecuteAsync(
-                "UPDATE Library SET LastScan = null WHERE Id IN @ids",
-                new { ids = libraryIds });
+        await _dbConnection.ExecuteAsync(
+            "UPDATE Library SET LastScan = null WHERE Id IN @ids",
+            new { ids = libraryIds });
 
-            List<int> movieIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> movieIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinMovie pm ON pm.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinMovie pm ON pm.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> episodeIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> episodeIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinEpisode pe ON pe.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinEpisode pe ON pe.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> seasonIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> seasonIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinSeason js ON js.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinSeason ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> showIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> showIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinShow ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN JellyfinShow ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            return movieIds.Append(showIds).Append(seasonIds).Append(episodeIds).ToList();
-        }
+        return movieIds.Append(showIds).Append(seasonIds).Append(episodeIds).ToList();
+    }
 
-        public Task<Option<JellyfinLibrary>> GetJellyfinLibrary(int jellyfinLibraryId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.JellyfinLibraries
-                .Include(l => l.Paths)
-                .OrderBy(l => l.Id) // https://github.com/dotnet/efcore/issues/22579
-                .SingleOrDefaultAsync(l => l.Id == jellyfinLibraryId)
-                .Map(Optional);
-        }
+    public Task<Option<JellyfinLibrary>> GetJellyfinLibrary(int jellyfinLibraryId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.JellyfinLibraries
+            .Include(l => l.Paths)
+            .OrderBy(l => l.Id) // https://github.com/dotnet/efcore/issues/22579
+            .SingleOrDefaultAsync(l => l.Id == jellyfinLibraryId)
+            .Map(Optional);
+    }
 
-        public async Task<Option<JellyfinMediaSource>> GetJellyfinByLibraryId(int jellyfinLibraryId)
-        {
-            int? id = await _dbConnection.QuerySingleOrDefaultAsync<int?>(
-                @"SELECT L.MediaSourceId FROM Library L
+    public async Task<Option<JellyfinMediaSource>> GetJellyfinByLibraryId(int jellyfinLibraryId)
+    {
+        int? id = await _dbConnection.QuerySingleOrDefaultAsync<int?>(
+            @"SELECT L.MediaSourceId FROM Library L
                 INNER JOIN JellyfinLibrary PL on L.Id = PL.Id
                 WHERE L.Id = @JellyfinLibraryId",
-                new { JellyfinLibraryId = jellyfinLibraryId });
+            new { JellyfinLibraryId = jellyfinLibraryId });
 
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            return await context.JellyfinMediaSources
-                .Include(p => p.Connections)
-                .Include(p => p.Libraries)
-                .OrderBy(p => p.Id)
-                .SingleOrDefaultAsync(p => p.Id == id)
-                .Map(Optional);
-        }
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+        return await context.JellyfinMediaSources
+            .Include(p => p.Connections)
+            .Include(p => p.Libraries)
+            .OrderBy(p => p.Id)
+            .SingleOrDefaultAsync(p => p.Id == id)
+            .Map(Optional);
+    }
 
-        public Task<List<JellyfinPathReplacement>> GetJellyfinPathReplacements(int jellyfinMediaSourceId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.JellyfinPathReplacements
-                .Filter(r => r.JellyfinMediaSourceId == jellyfinMediaSourceId)
-                .Include(jpr => jpr.JellyfinMediaSource)
-                .ToListAsync();
-        }
+    public Task<List<JellyfinPathReplacement>> GetJellyfinPathReplacements(int jellyfinMediaSourceId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.JellyfinPathReplacements
+            .Filter(r => r.JellyfinMediaSourceId == jellyfinMediaSourceId)
+            .Include(jpr => jpr.JellyfinMediaSource)
+            .ToListAsync();
+    }
 
-        public Task<List<JellyfinPathReplacement>> GetJellyfinPathReplacementsByLibraryId(int jellyfinLibraryPathId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.JellyfinPathReplacements
-                .FromSqlRaw(
-                    @"select jpr.* from LibraryPath lp
+    public Task<List<JellyfinPathReplacement>> GetJellyfinPathReplacementsByLibraryId(int jellyfinLibraryPathId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.JellyfinPathReplacements
+            .FromSqlRaw(
+                @"select jpr.* from LibraryPath lp
                     inner join JellyfinLibrary jl ON jl.Id = lp.LibraryId
                     inner join Library l ON l.Id = jl.Id
                     inner join JellyfinPathReplacement jpr on jpr.JellyfinMediaSourceId = l.MediaSourceId
                     where lp.Id = {0}",
-                    jellyfinLibraryPathId)
-                .Include(jpr => jpr.JellyfinMediaSource)
-                .ToListAsync();
-        }
+                jellyfinLibraryPathId)
+            .Include(jpr => jpr.JellyfinMediaSource)
+            .ToListAsync();
+    }
 
-        public async Task<Unit> UpdatePathReplacements(
-            int jellyfinMediaSourceId,
-            List<JellyfinPathReplacement> toAdd,
-            List<JellyfinPathReplacement> toUpdate,
-            List<JellyfinPathReplacement> toDelete)
+    public async Task<Unit> UpdatePathReplacements(
+        int jellyfinMediaSourceId,
+        List<JellyfinPathReplacement> toAdd,
+        List<JellyfinPathReplacement> toUpdate,
+        List<JellyfinPathReplacement> toDelete)
+    {
+        foreach (JellyfinPathReplacement add in toAdd)
         {
-            foreach (JellyfinPathReplacement add in toAdd)
-            {
-                await _dbConnection.ExecuteAsync(
-                    @"INSERT INTO JellyfinPathReplacement
+            await _dbConnection.ExecuteAsync(
+                @"INSERT INTO JellyfinPathReplacement
                     (JellyfinPath, LocalPath, JellyfinMediaSourceId)
                     VALUES (@JellyfinPath, @LocalPath, @JellyfinMediaSourceId)",
-                    new { add.JellyfinPath, add.LocalPath, JellyfinMediaSourceId = jellyfinMediaSourceId });
-            }
+                new { add.JellyfinPath, add.LocalPath, JellyfinMediaSourceId = jellyfinMediaSourceId });
+        }
 
-            foreach (JellyfinPathReplacement update in toUpdate)
-            {
-                await _dbConnection.ExecuteAsync(
-                    @"UPDATE JellyfinPathReplacement
+        foreach (JellyfinPathReplacement update in toUpdate)
+        {
+            await _dbConnection.ExecuteAsync(
+                @"UPDATE JellyfinPathReplacement
                     SET JellyfinPath = @JellyfinPath, LocalPath = @LocalPath
                     WHERE Id = @Id",
-                    new { update.JellyfinPath, update.LocalPath, update.Id });
-            }
+                new { update.JellyfinPath, update.LocalPath, update.Id });
+        }
 
-            foreach (JellyfinPathReplacement delete in toDelete)
+        foreach (JellyfinPathReplacement delete in toDelete)
+        {
+            await _dbConnection.ExecuteAsync(
+                @"DELETE FROM JellyfinPathReplacement WHERE Id = @Id",
+                new { delete.Id });
+        }
+
+        return Unit.Default;
+    }
+
+    public async Task<List<int>> DeleteAllJellyfin()
+    {
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+
+        List<JellyfinMediaSource> allMediaSources = await context.JellyfinMediaSources.ToListAsync();
+        var mediaSourceIds = allMediaSources.Map(ms => ms.Id).ToList();
+        context.JellyfinMediaSources.RemoveRange(allMediaSources);
+
+        List<JellyfinLibrary> allJellyfinLibraries = await context.JellyfinLibraries
+            .Where(l => mediaSourceIds.Contains(l.MediaSourceId))
+            .ToListAsync();
+        var libraryIds = allJellyfinLibraries.Map(l => l.Id).ToList();
+        context.JellyfinLibraries.RemoveRange(allJellyfinLibraries);
+
+        List<int> movieIds = await context.JellyfinMovies
+            .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
+            .Map(pm => pm.Id)
+            .ToListAsync();
+
+        List<int> showIds = await context.JellyfinShows
+            .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
+            .Map(ps => ps.Id)
+            .ToListAsync();
+
+        List<int> episodeIds = await context.JellyfinEpisodes
+            .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
+            .Map(ps => ps.Id)
+            .ToListAsync();
+
+        await context.SaveChangesAsync();
+
+        return movieIds.Append(showIds).Append(episodeIds).ToList();
+    }
+
+    public async Task<Unit> UpsertEmby(string address, string serverName, string operatingSystem)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<EmbyMediaSource> maybeExisting = dbContext.EmbyMediaSources
+            .Include(ms => ms.Connections)
+            .OrderBy(ms => ms.Id)
+            .HeadOrNone();
+
+        return await maybeExisting.Match(
+            async embyMediaSource =>
             {
-                await _dbConnection.ExecuteAsync(
-                    @"DELETE FROM JellyfinPathReplacement WHERE Id = @Id",
-                    new { delete.Id });
-            }
-
-            return Unit.Default;
-        }
-
-        public async Task<List<int>> DeleteAllJellyfin()
-        {
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-
-            List<JellyfinMediaSource> allMediaSources = await context.JellyfinMediaSources.ToListAsync();
-            var mediaSourceIds = allMediaSources.Map(ms => ms.Id).ToList();
-            context.JellyfinMediaSources.RemoveRange(allMediaSources);
-
-            List<JellyfinLibrary> allJellyfinLibraries = await context.JellyfinLibraries
-                .Where(l => mediaSourceIds.Contains(l.MediaSourceId))
-                .ToListAsync();
-            var libraryIds = allJellyfinLibraries.Map(l => l.Id).ToList();
-            context.JellyfinLibraries.RemoveRange(allJellyfinLibraries);
-
-            List<int> movieIds = await context.JellyfinMovies
-                .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
-                .Map(pm => pm.Id)
-                .ToListAsync();
-
-            List<int> showIds = await context.JellyfinShows
-                .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
-                .Map(ps => ps.Id)
-                .ToListAsync();
-
-            List<int> episodeIds = await context.JellyfinEpisodes
-                .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
-                .Map(ps => ps.Id)
-                .ToListAsync();
-
-            await context.SaveChangesAsync();
-
-            return movieIds.Append(showIds).Append(episodeIds).ToList();
-        }
-
-        public async Task<Unit> UpsertEmby(string address, string serverName, string operatingSystem)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<EmbyMediaSource> maybeExisting = dbContext.EmbyMediaSources
-                .Include(ms => ms.Connections)
-                .OrderBy(ms => ms.Id)
-                .HeadOrNone();
-
-            return await maybeExisting.Match(
-                async embyMediaSource =>
+                if (!embyMediaSource.Connections.Any())
                 {
-                    if (!embyMediaSource.Connections.Any())
-                    {
-                        embyMediaSource.Connections.Add(new EmbyConnection { Address = address });
-                    }
-                    else if (embyMediaSource.Connections.Head().Address != address)
-                    {
-                        embyMediaSource.Connections.Head().Address = address;
-                    }
-
-                    if (embyMediaSource.ServerName != serverName)
-                    {
-                        embyMediaSource.ServerName = serverName;
-                    }
-
-                    if (embyMediaSource.OperatingSystem != operatingSystem)
-                    {
-                        embyMediaSource.OperatingSystem = operatingSystem;
-                    }
-
-                    await dbContext.SaveChangesAsync();
-
-                    return Unit.Default;
-                },
-                async () =>
+                    embyMediaSource.Connections.Add(new EmbyConnection { Address = address });
+                }
+                else if (embyMediaSource.Connections.Head().Address != address)
                 {
-                    var mediaSource = new EmbyMediaSource
+                    embyMediaSource.Connections.Head().Address = address;
+                }
+
+                if (embyMediaSource.ServerName != serverName)
+                {
+                    embyMediaSource.ServerName = serverName;
+                }
+
+                if (embyMediaSource.OperatingSystem != operatingSystem)
+                {
+                    embyMediaSource.OperatingSystem = operatingSystem;
+                }
+
+                await dbContext.SaveChangesAsync();
+
+                return Unit.Default;
+            },
+            async () =>
+            {
+                var mediaSource = new EmbyMediaSource
+                {
+                    ServerName = serverName,
+                    OperatingSystem = operatingSystem,
+                    Connections = new List<EmbyConnection>
                     {
-                        ServerName = serverName,
-                        OperatingSystem = operatingSystem,
-                        Connections = new List<EmbyConnection>
-                        {
-                            new() { Address = address }
-                        },
-                        PathReplacements = new List<EmbyPathReplacement>()
-                    };
+                        new() { Address = address }
+                    },
+                    PathReplacements = new List<EmbyPathReplacement>()
+                };
 
-                    await dbContext.AddAsync(mediaSource);
-                    await dbContext.SaveChangesAsync();
+                await dbContext.AddAsync(mediaSource);
+                await dbContext.SaveChangesAsync();
 
-                    return Unit.Default;
-                });
-        }
+                return Unit.Default;
+            });
+    }
 
-        public Task<List<EmbyMediaSource>> GetAllEmby()
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.EmbyMediaSources
-                .Include(p => p.Connections)
-                .ToListAsync();
-        }
+    public Task<List<EmbyMediaSource>> GetAllEmby()
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.EmbyMediaSources
+            .Include(p => p.Connections)
+            .ToListAsync();
+    }
 
-        public Task<Option<EmbyMediaSource>> GetEmby(int id)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.EmbyMediaSources
-                .Include(p => p.Connections)
-                .Include(p => p.Libraries)
-                .Include(p => p.PathReplacements)
-                .OrderBy(s => s.Id) // https://github.com/dotnet/efcore/issues/22579
-                .SingleOrDefaultAsync(p => p.Id == id)
-                .Map(Optional);
-        }
+    public Task<Option<EmbyMediaSource>> GetEmby(int id)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.EmbyMediaSources
+            .Include(p => p.Connections)
+            .Include(p => p.Libraries)
+            .Include(p => p.PathReplacements)
+            .OrderBy(s => s.Id) // https://github.com/dotnet/efcore/issues/22579
+            .SingleOrDefaultAsync(p => p.Id == id)
+            .Map(Optional);
+    }
 
-        public async Task<Option<EmbyMediaSource>> GetEmbyByLibraryId(int embyLibraryId)
-        {
-            int? id = await _dbConnection.QuerySingleOrDefaultAsync<int?>(
-                @"SELECT L.MediaSourceId FROM Library L
+    public async Task<Option<EmbyMediaSource>> GetEmbyByLibraryId(int embyLibraryId)
+    {
+        int? id = await _dbConnection.QuerySingleOrDefaultAsync<int?>(
+            @"SELECT L.MediaSourceId FROM Library L
                 INNER JOIN EmbyLibrary PL on L.Id = PL.Id
                 WHERE L.Id = @EmbyLibraryId",
-                new { EmbyLibraryId = embyLibraryId });
+            new { EmbyLibraryId = embyLibraryId });
 
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            return await context.EmbyMediaSources
-                .Include(p => p.Connections)
-                .Include(p => p.Libraries)
-                .OrderBy(p => p.Id)
-                .SingleOrDefaultAsync(p => p.Id == id)
-                .Map(Optional);
-        }
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+        return await context.EmbyMediaSources
+            .Include(p => p.Connections)
+            .Include(p => p.Libraries)
+            .OrderBy(p => p.Id)
+            .SingleOrDefaultAsync(p => p.Id == id)
+            .Map(Optional);
+    }
 
-        public Task<Option<EmbyLibrary>> GetEmbyLibrary(int embyLibraryId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.EmbyLibraries
-                .Include(l => l.Paths)
-                .OrderBy(l => l.Id) // https://github.com/dotnet/efcore/issues/22579
-                .SingleOrDefaultAsync(l => l.Id == embyLibraryId)
-                .Map(Optional);
-        }
+    public Task<Option<EmbyLibrary>> GetEmbyLibrary(int embyLibraryId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.EmbyLibraries
+            .Include(l => l.Paths)
+            .OrderBy(l => l.Id) // https://github.com/dotnet/efcore/issues/22579
+            .SingleOrDefaultAsync(l => l.Id == embyLibraryId)
+            .Map(Optional);
+    }
 
-        public Task<List<EmbyLibrary>> GetEmbyLibraries(int embyMediaSourceId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.EmbyLibraries
-                .Filter(l => l.MediaSourceId == embyMediaSourceId)
-                .ToListAsync();
-        }
+    public Task<List<EmbyLibrary>> GetEmbyLibraries(int embyMediaSourceId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.EmbyLibraries
+            .Filter(l => l.MediaSourceId == embyMediaSourceId)
+            .ToListAsync();
+    }
 
-        public Task<List<EmbyPathReplacement>> GetEmbyPathReplacements(int embyMediaSourceId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.EmbyPathReplacements
-                .Filter(r => r.EmbyMediaSourceId == embyMediaSourceId)
-                .Include(jpr => jpr.EmbyMediaSource)
-                .ToListAsync();
-        }
+    public Task<List<EmbyPathReplacement>> GetEmbyPathReplacements(int embyMediaSourceId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.EmbyPathReplacements
+            .Filter(r => r.EmbyMediaSourceId == embyMediaSourceId)
+            .Include(jpr => jpr.EmbyMediaSource)
+            .ToListAsync();
+    }
 
-        public Task<List<EmbyPathReplacement>> GetEmbyPathReplacementsByLibraryId(int embyLibraryPathId)
-        {
-            using TvContext context = _dbContextFactory.CreateDbContext();
-            return context.EmbyPathReplacements
-                .FromSqlRaw(
-                    @"select epr.* from LibraryPath lp
+    public Task<List<EmbyPathReplacement>> GetEmbyPathReplacementsByLibraryId(int embyLibraryPathId)
+    {
+        using TvContext context = _dbContextFactory.CreateDbContext();
+        return context.EmbyPathReplacements
+            .FromSqlRaw(
+                @"select epr.* from LibraryPath lp
                     inner join EmbyLibrary el ON el.Id = lp.LibraryId
                     inner join Library l ON l.Id = el.Id
                     inner join EmbyPathReplacement epr on epr.EmbyMediaSourceId = l.MediaSourceId
                     where lp.Id = {0}",
-                    embyLibraryPathId)
-                .Include(jpr => jpr.EmbyMediaSource)
-                .ToListAsync();
-        }
+                embyLibraryPathId)
+            .Include(jpr => jpr.EmbyMediaSource)
+            .ToListAsync();
+    }
 
-        public async Task<Unit> UpdatePathReplacements(
-            int embyMediaSourceId,
-            List<EmbyPathReplacement> toAdd,
-            List<EmbyPathReplacement> toUpdate,
-            List<EmbyPathReplacement> toDelete)
+    public async Task<Unit> UpdatePathReplacements(
+        int embyMediaSourceId,
+        List<EmbyPathReplacement> toAdd,
+        List<EmbyPathReplacement> toUpdate,
+        List<EmbyPathReplacement> toDelete)
+    {
+        foreach (EmbyPathReplacement add in toAdd)
         {
-            foreach (EmbyPathReplacement add in toAdd)
-            {
-                await _dbConnection.ExecuteAsync(
-                    @"INSERT INTO EmbyPathReplacement
+            await _dbConnection.ExecuteAsync(
+                @"INSERT INTO EmbyPathReplacement
                     (EmbyPath, LocalPath, EmbyMediaSourceId)
                     VALUES (@EmbyPath, @LocalPath, @EmbyMediaSourceId)",
-                    new { add.EmbyPath, add.LocalPath, EmbyMediaSourceId = embyMediaSourceId });
-            }
+                new { add.EmbyPath, add.LocalPath, EmbyMediaSourceId = embyMediaSourceId });
+        }
 
-            foreach (EmbyPathReplacement update in toUpdate)
-            {
-                await _dbConnection.ExecuteAsync(
-                    @"UPDATE EmbyPathReplacement
+        foreach (EmbyPathReplacement update in toUpdate)
+        {
+            await _dbConnection.ExecuteAsync(
+                @"UPDATE EmbyPathReplacement
                     SET EmbyPath = @EmbyPath, LocalPath = @LocalPath
                     WHERE Id = @Id",
-                    new { update.EmbyPath, update.LocalPath, update.Id });
-            }
-
-            foreach (EmbyPathReplacement delete in toDelete)
-            {
-                await _dbConnection.ExecuteAsync(
-                    @"DELETE FROM EmbyPathReplacement WHERE Id = @Id",
-                    new { delete.Id });
-            }
-
-            return Unit.Default;
+                new { update.EmbyPath, update.LocalPath, update.Id });
         }
 
-        public async Task<List<int>> DeleteAllEmby()
+        foreach (EmbyPathReplacement delete in toDelete)
         {
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-
-            List<EmbyMediaSource> allMediaSources = await context.EmbyMediaSources.ToListAsync();
-            var mediaSourceIds = allMediaSources.Map(ms => ms.Id).ToList();
-            context.EmbyMediaSources.RemoveRange(allMediaSources);
-
-            List<EmbyLibrary> allEmbyLibraries = await context.EmbyLibraries
-                .Where(l => mediaSourceIds.Contains(l.MediaSourceId))
-                .ToListAsync();
-            var libraryIds = allEmbyLibraries.Map(l => l.Id).ToList();
-            context.EmbyLibraries.RemoveRange(allEmbyLibraries);
-
-            List<int> movieIds = await context.EmbyMovies
-                .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
-                .Map(pm => pm.Id)
-                .ToListAsync();
-
-            List<int> showIds = await context.EmbyShows
-                .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
-                .Map(ps => ps.Id)
-                .ToListAsync();
-
-            List<int> episodeIds = await context.EmbyEpisodes
-                .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
-                .Map(ps => ps.Id)
-                .ToListAsync();
-
-            await context.SaveChangesAsync();
-
-            return movieIds.Append(showIds).Append(episodeIds).ToList();
+            await _dbConnection.ExecuteAsync(
+                @"DELETE FROM EmbyPathReplacement WHERE Id = @Id",
+                new { delete.Id });
         }
 
-        public Task<Unit> EnableEmbyLibrarySync(IEnumerable<int> libraryIds) =>
-            _dbConnection.ExecuteAsync(
-                "UPDATE EmbyLibrary SET ShouldSyncItems = 1 WHERE Id IN @ids",
-                new { ids = libraryIds }).Map(_ => Unit.Default);
+        return Unit.Default;
+    }
 
-        public async Task<List<int>> DisableEmbyLibrarySync(List<int> libraryIds)
-        {
-            await _dbConnection.ExecuteAsync(
-                "UPDATE EmbyLibrary SET ShouldSyncItems = 0 WHERE Id IN @ids",
-                new { ids = libraryIds });
+    public async Task<List<int>> DeleteAllEmby()
+    {
+        await using TvContext context = _dbContextFactory.CreateDbContext();
 
-            await _dbConnection.ExecuteAsync(
-                "UPDATE Library SET LastScan = null WHERE Id IN @ids",
-                new { ids = libraryIds });
+        List<EmbyMediaSource> allMediaSources = await context.EmbyMediaSources.ToListAsync();
+        var mediaSourceIds = allMediaSources.Map(ms => ms.Id).ToList();
+        context.EmbyMediaSources.RemoveRange(allMediaSources);
 
-            List<int> movieIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<EmbyLibrary> allEmbyLibraries = await context.EmbyLibraries
+            .Where(l => mediaSourceIds.Contains(l.MediaSourceId))
+            .ToListAsync();
+        var libraryIds = allEmbyLibraries.Map(l => l.Id).ToList();
+        context.EmbyLibraries.RemoveRange(allEmbyLibraries);
+
+        List<int> movieIds = await context.EmbyMovies
+            .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
+            .Map(pm => pm.Id)
+            .ToListAsync();
+
+        List<int> showIds = await context.EmbyShows
+            .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
+            .Map(ps => ps.Id)
+            .ToListAsync();
+
+        List<int> episodeIds = await context.EmbyEpisodes
+            .Where(m => libraryIds.Contains(m.LibraryPath.LibraryId))
+            .Map(ps => ps.Id)
+            .ToListAsync();
+
+        await context.SaveChangesAsync();
+
+        return movieIds.Append(showIds).Append(episodeIds).ToList();
+    }
+
+    public Task<Unit> EnableEmbyLibrarySync(IEnumerable<int> libraryIds) =>
+        _dbConnection.ExecuteAsync(
+            "UPDATE EmbyLibrary SET ShouldSyncItems = 1 WHERE Id IN @ids",
+            new { ids = libraryIds }).Map(_ => Unit.Default);
+
+    public async Task<List<int>> DisableEmbyLibrarySync(List<int> libraryIds)
+    {
+        await _dbConnection.ExecuteAsync(
+            "UPDATE EmbyLibrary SET ShouldSyncItems = 0 WHERE Id IN @ids",
+            new { ids = libraryIds });
+
+        await _dbConnection.ExecuteAsync(
+            "UPDATE Library SET LastScan = null WHERE Id IN @ids",
+            new { ids = libraryIds });
+
+        List<int> movieIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbyMovie pm ON pm.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbyMovie pm ON pm.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> episodeIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> episodeIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbyEpisode pe ON pe.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbyEpisode pe ON pe.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> seasonIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> seasonIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbySeason es ON es.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbySeason ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            List<int> showIds = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        List<int> showIds = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbyShow ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids",
-                new { ids = libraryIds }).Map(result => result.ToList());
+            new { ids = libraryIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN EmbyShow ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 INNER JOIN Library l ON l.Id = lp.LibraryId
                 WHERE l.Id IN @ids)",
-                new { ids = libraryIds });
+            new { ids = libraryIds });
 
-            return movieIds.Append(showIds).Append(seasonIds).Append(episodeIds).ToList();
-        }
+        return movieIds.Append(showIds).Append(seasonIds).Append(episodeIds).ToList();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/MetadataRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/MetadataRepository.cs
index b691d4c63..bb891c3f0 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/MetadataRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/MetadataRepository.cs
@@ -1,448 +1,442 @@
-using System;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class MetadataRepository : IMetadataRepository
 {
-    public class MetadataRepository : IMetadataRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public MetadataRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public MetadataRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+    public Task<bool> RemoveActor(Actor actor) =>
+        _dbConnection.ExecuteAsync("DELETE FROM Actor WHERE Id = @ActorId", new { ActorId = actor.Id })
+            .Map(result => result > 0);
+
+    public async Task<bool> Update(Metadata metadata)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        dbContext.Entry(metadata).State = EntityState.Modified;
+        return await dbContext.SaveChangesAsync() > 0;
+    }
+
+    public async Task<bool> Add(Metadata metadata)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        dbContext.Entry(metadata).State = EntityState.Added;
+
+        foreach (Genre genre in Optional(metadata.Genres).Flatten())
         {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
+            dbContext.Entry(genre).State = EntityState.Added;
         }
 
-        public Task<bool> RemoveActor(Actor actor) =>
-            _dbConnection.ExecuteAsync("DELETE FROM Actor WHERE Id = @ActorId", new { ActorId = actor.Id })
-                .Map(result => result > 0);
-
-        public async Task<bool> Update(Metadata metadata)
+        foreach (Tag tag in Optional(metadata.Tags).Flatten())
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            dbContext.Entry(metadata).State = EntityState.Modified;
-            return await dbContext.SaveChangesAsync() > 0;
+            dbContext.Entry(tag).State = EntityState.Added;
         }
 
-        public async Task<bool> Add(Metadata metadata)
+        foreach (Studio studio in Optional(metadata.Studios).Flatten())
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            dbContext.Entry(metadata).State = EntityState.Added;
-
-            foreach (Genre genre in Optional(metadata.Genres).Flatten())
-            {
-                dbContext.Entry(genre).State = EntityState.Added;
-            }
-
-            foreach (Tag tag in Optional(metadata.Tags).Flatten())
-            {
-                dbContext.Entry(tag).State = EntityState.Added;
-            }
-
-            foreach (Studio studio in Optional(metadata.Studios).Flatten())
-            {
-                dbContext.Entry(studio).State = EntityState.Added;
-            }
-
-            if (metadata is ArtistMetadata artistMetadata)
-            {
-                foreach (Style style in Optional(artistMetadata.Styles).Flatten())
-                {
-                    dbContext.Entry(style).State = EntityState.Added;
-                }
-
-                foreach (Mood mood in Optional(artistMetadata.Moods).Flatten())
-                {
-                    dbContext.Entry(mood).State = EntityState.Added;
-                }
-            }
-
-            foreach (Actor actor in Optional(metadata.Actors).Flatten())
-            {
-                dbContext.Entry(actor).State = EntityState.Added;
-                if (actor.Artwork != null)
-                {
-                    dbContext.Entry(actor.Artwork).State = EntityState.Added;
-                }
-            }
-
-            foreach (MetadataGuid guid in Optional(metadata.Guids).Flatten())
-            {
-                dbContext.Entry(guid).State = EntityState.Added;
-            }
-
-            if (metadata is MovieMetadata movieMetadata)
-            {
-                foreach (Director director in Optional(movieMetadata.Directors).Flatten())
-                {
-                    dbContext.Entry(director).State = EntityState.Added;
-                }
-
-                foreach (Writer writer in Optional(movieMetadata.Writers).Flatten())
-                {
-                    dbContext.Entry(writer).State = EntityState.Added;
-                }
-            }
-
-            if (metadata is EpisodeMetadata episodeMetadata)
-            {
-                foreach (Director director in Optional(episodeMetadata.Directors).Flatten())
-                {
-                    dbContext.Entry(director).State = EntityState.Added;
-                }
-
-                foreach (Writer writer in Optional(episodeMetadata.Writers).Flatten())
-                {
-                    dbContext.Entry(writer).State = EntityState.Added;
-                }
-            }
-
-            return await dbContext.SaveChangesAsync() > 0;
+            dbContext.Entry(studio).State = EntityState.Added;
         }
 
-        public async Task<bool> UpdateLocalStatistics(
-            MediaItem mediaItem,
-            MediaVersion incoming,
-            bool updateVersion = true)
+        if (metadata is ArtistMetadata artistMetadata)
         {
-            int mediaVersionId = mediaItem.GetHeadVersion().Id;
+            foreach (Style style in Optional(artistMetadata.Styles).Flatten())
+            {
+                dbContext.Entry(style).State = EntityState.Added;
+            }
+
+            foreach (Mood mood in Optional(artistMetadata.Moods).Flatten())
+            {
+                dbContext.Entry(mood).State = EntityState.Added;
+            }
+        }
+
+        foreach (Actor actor in Optional(metadata.Actors).Flatten())
+        {
+            dbContext.Entry(actor).State = EntityState.Added;
+            if (actor.Artwork != null)
+            {
+                dbContext.Entry(actor.Artwork).State = EntityState.Added;
+            }
+        }
+
+        foreach (MetadataGuid guid in Optional(metadata.Guids).Flatten())
+        {
+            dbContext.Entry(guid).State = EntityState.Added;
+        }
+
+        if (metadata is MovieMetadata movieMetadata)
+        {
+            foreach (Director director in Optional(movieMetadata.Directors).Flatten())
+            {
+                dbContext.Entry(director).State = EntityState.Added;
+            }
+
+            foreach (Writer writer in Optional(movieMetadata.Writers).Flatten())
+            {
+                dbContext.Entry(writer).State = EntityState.Added;
+            }
+        }
+
+        if (metadata is EpisodeMetadata episodeMetadata)
+        {
+            foreach (Director director in Optional(episodeMetadata.Directors).Flatten())
+            {
+                dbContext.Entry(director).State = EntityState.Added;
+            }
+
+            foreach (Writer writer in Optional(episodeMetadata.Writers).Flatten())
+            {
+                dbContext.Entry(writer).State = EntityState.Added;
+            }
+        }
+
+        return await dbContext.SaveChangesAsync() > 0;
+    }
+
+    public async Task<bool> UpdateLocalStatistics(
+        MediaItem mediaItem,
+        MediaVersion incoming,
+        bool updateVersion = true)
+    {
+        int mediaVersionId = mediaItem.GetHeadVersion().Id;
             
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<MediaVersion> maybeVersion = await dbContext.MediaVersions
-                .Include(v => v.Streams)
-                .Include(v => v.Chapters)
-                .Include(v => v.MediaFiles)
-                .OrderBy(v => v.Id)
-                .SingleOrDefaultAsync(v => v.Id == mediaVersionId)
-                .Map(Optional);
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<MediaVersion> maybeVersion = await dbContext.MediaVersions
+            .Include(v => v.Streams)
+            .Include(v => v.Chapters)
+            .Include(v => v.MediaFiles)
+            .OrderBy(v => v.Id)
+            .SingleOrDefaultAsync(v => v.Id == mediaVersionId)
+            .Map(Optional);
 
-            return await maybeVersion.Match(
-                async existing =>
+        return await maybeVersion.Match(
+            async existing =>
+            {
+                if (updateVersion)
                 {
-                    if (updateVersion)
-                    {
-                        existing.DateUpdated = incoming.DateUpdated;
-                        existing.Duration = incoming.Duration;
-                        existing.SampleAspectRatio = incoming.SampleAspectRatio;
-                        existing.DisplayAspectRatio = incoming.DisplayAspectRatio;
-                        existing.Width = incoming.Width;
-                        existing.Height = incoming.Height;
-                        existing.VideoScanKind = incoming.VideoScanKind;
-                        existing.RFrameRate = incoming.RFrameRate;
-                    }
+                    existing.DateUpdated = incoming.DateUpdated;
+                    existing.Duration = incoming.Duration;
+                    existing.SampleAspectRatio = incoming.SampleAspectRatio;
+                    existing.DisplayAspectRatio = incoming.DisplayAspectRatio;
+                    existing.Width = incoming.Width;
+                    existing.Height = incoming.Height;
+                    existing.VideoScanKind = incoming.VideoScanKind;
+                    existing.RFrameRate = incoming.RFrameRate;
+                }
 
-                    var toAdd = incoming.Streams.Filter(s => existing.Streams.All(es => es.Index != s.Index)).ToList();
-                    var toRemove = existing.Streams.Filter(es => incoming.Streams.All(s => s.Index != es.Index))
-                        .ToList();
-                    var toUpdate = incoming.Streams.Except(toAdd).ToList();
+                var toAdd = incoming.Streams.Filter(s => existing.Streams.All(es => es.Index != s.Index)).ToList();
+                var toRemove = existing.Streams.Filter(es => incoming.Streams.All(s => s.Index != es.Index))
+                    .ToList();
+                var toUpdate = incoming.Streams.Except(toAdd).ToList();
 
-                    // add
-                    existing.Streams.AddRange(toAdd);
+                // add
+                existing.Streams.AddRange(toAdd);
 
-                    // remove
-                    existing.Streams.RemoveAll(s => toRemove.Contains(s));
+                // remove
+                existing.Streams.RemoveAll(s => toRemove.Contains(s));
 
-                    // update
-                    foreach (MediaStream incomingStream in toUpdate)
-                    {
-                        MediaStream existingStream = existing.Streams.First(s => s.Index == incomingStream.Index);
+                // update
+                foreach (MediaStream incomingStream in toUpdate)
+                {
+                    MediaStream existingStream = existing.Streams.First(s => s.Index == incomingStream.Index);
 
-                        existingStream.Codec = incomingStream.Codec;
-                        existingStream.Profile = incomingStream.Profile;
-                        existingStream.MediaStreamKind = incomingStream.MediaStreamKind;
-                        existingStream.Language = incomingStream.Language;
-                        existingStream.Channels = incomingStream.Channels;
-                        existingStream.Title = incomingStream.Title;
-                        existingStream.Default = incomingStream.Default;
-                        existingStream.Forced = incomingStream.Forced;
-                        existingStream.AttachedPic = incomingStream.AttachedPic;
-                        existingStream.PixelFormat = incomingStream.PixelFormat;
-                        existingStream.BitsPerRawSample = incomingStream.BitsPerRawSample;
-                    }
+                    existingStream.Codec = incomingStream.Codec;
+                    existingStream.Profile = incomingStream.Profile;
+                    existingStream.MediaStreamKind = incomingStream.MediaStreamKind;
+                    existingStream.Language = incomingStream.Language;
+                    existingStream.Channels = incomingStream.Channels;
+                    existingStream.Title = incomingStream.Title;
+                    existingStream.Default = incomingStream.Default;
+                    existingStream.Forced = incomingStream.Forced;
+                    existingStream.AttachedPic = incomingStream.AttachedPic;
+                    existingStream.PixelFormat = incomingStream.PixelFormat;
+                    existingStream.BitsPerRawSample = incomingStream.BitsPerRawSample;
+                }
                     
-                    var chaptersToAdd = incoming.Chapters
-                        .Filter(s => existing.Chapters.All(es => es.ChapterId != s.ChapterId))
-                        .ToList();
-                    var chaptersToRemove = existing.Chapters
-                        .Filter(es => incoming.Chapters.All(s => s.ChapterId != es.ChapterId))
-                        .ToList();
-                    var chaptersToUpdate = incoming.Chapters.Except(chaptersToAdd).ToList();
+                var chaptersToAdd = incoming.Chapters
+                    .Filter(s => existing.Chapters.All(es => es.ChapterId != s.ChapterId))
+                    .ToList();
+                var chaptersToRemove = existing.Chapters
+                    .Filter(es => incoming.Chapters.All(s => s.ChapterId != es.ChapterId))
+                    .ToList();
+                var chaptersToUpdate = incoming.Chapters.Except(chaptersToAdd).ToList();
 
-                    // add
-                    existing.Chapters.AddRange(chaptersToAdd);
+                // add
+                existing.Chapters.AddRange(chaptersToAdd);
 
-                    // remove
-                    existing.Chapters.RemoveAll(chaptersToRemove.Contains);
+                // remove
+                existing.Chapters.RemoveAll(chaptersToRemove.Contains);
 
-                    // update
-                    foreach (MediaChapter incomingChapter in chaptersToUpdate)
-                    {
-                        MediaChapter existingChapter = existing.Chapters
-                            .First(s => s.ChapterId == incomingChapter.ChapterId);
-
-                        existingChapter.StartTime = incomingChapter.StartTime;
-                        existingChapter.EndTime = incomingChapter.EndTime;
-                        existingChapter.Title = incomingChapter.Title;
-                    }
-
-                    if (await dbContext.SaveChangesAsync() <= 0)
-                    {
-                        return false;
-                    }
-
-                    // reload the media versions so we can properly index the duration
-                    switch (mediaItem)
-                    {
-                        case Movie movie:
-                            movie.MediaVersions.Clear();
-                            movie.MediaVersions.Add(existing);
-                            break;
-                        case Episode episode:
-                            episode.MediaVersions.Clear();
-                            episode.MediaVersions.Add(existing);
-                            break;
-                        case MusicVideo musicVideo:
-                            musicVideo.MediaVersions.Clear();
-                            musicVideo.MediaVersions.Add(existing);
-                            break;
-                        case OtherVideo otherVideo:
-                            otherVideo.MediaVersions.Clear();
-                            otherVideo.MediaVersions.Add(existing);
-                            break;
-                        case Song song:
-                            song.MediaVersions.Clear();
-                            song.MediaVersions.Add(existing);
-                            break;
-                    }
-
-                    return true;
-                },
-                () => Task.FromResult(false));
-        }
-
-        public Task<bool> UpdatePlexStatistics(int mediaVersionId, MediaVersion incoming) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE MediaVersion SET
-                  DateUpdated = @DateUpdated
-                  WHERE Id = @MediaVersionId",
-                new
+                // update
+                foreach (MediaChapter incomingChapter in chaptersToUpdate)
                 {
-                    incoming.DateUpdated,
-                    MediaVersionId = mediaVersionId
-                }).Map(result => result > 0);
+                    MediaChapter existingChapter = existing.Chapters
+                        .First(s => s.ChapterId == incomingChapter.ChapterId);
 
-        public Task<Unit> UpdateArtworkPath(Artwork artwork) =>
-            _dbConnection.ExecuteAsync(
-                "UPDATE Artwork SET Path = @Path, SourcePath = @SourcePath, DateUpdated = @DateUpdated, BlurHash43 = @BlurHash43, BlurHash54 = @BlurHash54, BlurHash64 = @BlurHash64 WHERE Id = @Id",
-                new { artwork.Path, artwork.SourcePath, artwork.DateUpdated, artwork.BlurHash43, artwork.BlurHash54, artwork.BlurHash64, artwork.Id }).ToUnit();
-
-        public Task<Unit> AddArtwork(Metadata metadata, Artwork artwork)
-        {
-            var parameters = new
-            {
-                artwork.ArtworkKind, metadata.Id, artwork.DateAdded, artwork.DateUpdated, artwork.Path,
-                artwork.SourcePath, artwork.BlurHash43, artwork.BlurHash54, artwork.BlurHash64
-            };
-
-            return metadata switch
-            {
-                MovieMetadata => _dbConnection.ExecuteAsync(
-                        @"INSERT INTO Artwork (ArtworkKind, MovieMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
-                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
-                        parameters)
-                    .ToUnit(),
-                ShowMetadata => _dbConnection.ExecuteAsync(
-                        @"INSERT INTO Artwork (ArtworkKind, ShowMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
-                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
-                        parameters)
-                    .ToUnit(),
-                SeasonMetadata => _dbConnection.ExecuteAsync(
-                        @"INSERT INTO Artwork (ArtworkKind, SeasonMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
-                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
-                        parameters)
-                    .ToUnit(),
-                EpisodeMetadata => _dbConnection.ExecuteAsync(
-                        @"INSERT INTO Artwork (ArtworkKind, EpisodeMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
-                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
-                        parameters)
-                    .ToUnit(),
-                ArtistMetadata => _dbConnection.ExecuteAsync(
-                        @"INSERT INTO Artwork (ArtworkKind, ArtistMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
-                            Values (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
-                        parameters)
-                    .ToUnit(),
-                MusicVideoMetadata => _dbConnection.ExecuteAsync(
-                        @"INSERT INTO Artwork (ArtworkKind, MusicVideoMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
-                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
-                        parameters)
-                    .ToUnit(),
-                SongMetadata => _dbConnection.ExecuteAsync(
-                        @"INSERT INTO Artwork (ArtworkKind, SongMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
-                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
-                        parameters)
-                    .ToUnit(),
-                _ => Task.FromResult(Unit.Default)
-            };
-        }
-
-        public Task<Unit> RemoveArtwork(Metadata metadata, ArtworkKind artworkKind) =>
-            _dbConnection.ExecuteAsync(
-                @"DELETE FROM Artwork WHERE ArtworkKind = @ArtworkKind AND (MovieMetadataId = @Id
-                OR ShowMetadataId = @Id OR SeasonMetadataId = @Id OR EpisodeMetadataId = @Id)",
-                new { ArtworkKind = artworkKind, metadata.Id }).ToUnit();
-
-        public async Task<bool> CloneArtwork(
-            Metadata metadata,
-            Option<Artwork> maybeArtwork,
-            ArtworkKind artworkKind,
-            string sourcePath,
-            DateTime lastWriteTime)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<Artwork> maybeExisting = await dbContext.Artwork
-                .AsNoTracking()
-                .Filter(
-                    a => a.SourcePath == sourcePath && a.ArtworkKind == artworkKind && a.DateUpdated == lastWriteTime)
-                .FirstOrDefaultAsync()
-                .Map(Optional);
-            foreach (Artwork existing in maybeExisting)
-            {
-                Artwork artwork = await maybeArtwork.IfNoneAsync(new Artwork());
-                if (maybeArtwork.IsNone)
-                {
-                    metadata.Artwork.Add(artwork);
+                    existingChapter.StartTime = incomingChapter.StartTime;
+                    existingChapter.EndTime = incomingChapter.EndTime;
+                    existingChapter.Title = incomingChapter.Title;
                 }
 
-                artwork.Path = existing.Path;
-                artwork.SourcePath = existing.SourcePath;
-                artwork.ArtworkKind = artworkKind;
-                artwork.BlurHash43 = existing.BlurHash43;
-                artwork.BlurHash54 = existing.BlurHash54;
-                artwork.BlurHash64 = existing.BlurHash64;
-                artwork.DateAdded = existing.DateAdded;
-                artwork.DateUpdated = existing.DateUpdated;
-
-                if (maybeArtwork.IsNone)
+                if (await dbContext.SaveChangesAsync() <= 0)
                 {
-                    await AddArtwork(metadata, artwork);
+                    return false;
                 }
-                else
+
+                // reload the media versions so we can properly index the duration
+                switch (mediaItem)
                 {
-                    await UpdateArtworkPath(artwork);
+                    case Movie movie:
+                        movie.MediaVersions.Clear();
+                        movie.MediaVersions.Add(existing);
+                        break;
+                    case Episode episode:
+                        episode.MediaVersions.Clear();
+                        episode.MediaVersions.Add(existing);
+                        break;
+                    case MusicVideo musicVideo:
+                        musicVideo.MediaVersions.Clear();
+                        musicVideo.MediaVersions.Add(existing);
+                        break;
+                    case OtherVideo otherVideo:
+                        otherVideo.MediaVersions.Clear();
+                        otherVideo.MediaVersions.Add(existing);
+                        break;
+                    case Song song:
+                        song.MediaVersions.Clear();
+                        song.MediaVersions.Add(existing);
+                        break;
                 }
 
                 return true;
+            },
+            () => Task.FromResult(false));
+    }
+
+    public Task<bool> UpdatePlexStatistics(int mediaVersionId, MediaVersion incoming) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE MediaVersion SET
+                  DateUpdated = @DateUpdated
+                  WHERE Id = @MediaVersionId",
+            new
+            {
+                incoming.DateUpdated,
+                MediaVersionId = mediaVersionId
+            }).Map(result => result > 0);
+
+    public Task<Unit> UpdateArtworkPath(Artwork artwork) =>
+        _dbConnection.ExecuteAsync(
+            "UPDATE Artwork SET Path = @Path, SourcePath = @SourcePath, DateUpdated = @DateUpdated, BlurHash43 = @BlurHash43, BlurHash54 = @BlurHash54, BlurHash64 = @BlurHash64 WHERE Id = @Id",
+            new { artwork.Path, artwork.SourcePath, artwork.DateUpdated, artwork.BlurHash43, artwork.BlurHash54, artwork.BlurHash64, artwork.Id }).ToUnit();
+
+    public Task<Unit> AddArtwork(Metadata metadata, Artwork artwork)
+    {
+        var parameters = new
+        {
+            artwork.ArtworkKind, metadata.Id, artwork.DateAdded, artwork.DateUpdated, artwork.Path,
+            artwork.SourcePath, artwork.BlurHash43, artwork.BlurHash54, artwork.BlurHash64
+        };
+
+        return metadata switch
+        {
+            MovieMetadata => _dbConnection.ExecuteAsync(
+                    @"INSERT INTO Artwork (ArtworkKind, MovieMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
+                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
+                    parameters)
+                .ToUnit(),
+            ShowMetadata => _dbConnection.ExecuteAsync(
+                    @"INSERT INTO Artwork (ArtworkKind, ShowMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
+                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
+                    parameters)
+                .ToUnit(),
+            SeasonMetadata => _dbConnection.ExecuteAsync(
+                    @"INSERT INTO Artwork (ArtworkKind, SeasonMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
+                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
+                    parameters)
+                .ToUnit(),
+            EpisodeMetadata => _dbConnection.ExecuteAsync(
+                    @"INSERT INTO Artwork (ArtworkKind, EpisodeMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
+                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
+                    parameters)
+                .ToUnit(),
+            ArtistMetadata => _dbConnection.ExecuteAsync(
+                    @"INSERT INTO Artwork (ArtworkKind, ArtistMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
+                            Values (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
+                    parameters)
+                .ToUnit(),
+            MusicVideoMetadata => _dbConnection.ExecuteAsync(
+                    @"INSERT INTO Artwork (ArtworkKind, MusicVideoMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
+                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
+                    parameters)
+                .ToUnit(),
+            SongMetadata => _dbConnection.ExecuteAsync(
+                    @"INSERT INTO Artwork (ArtworkKind, SongMetadataId, DateAdded, DateUpdated, Path, SourcePath, BlurHash43, BlurHash54, BlurHash64)
+                            VALUES (@ArtworkKind, @Id, @DateAdded, @DateUpdated, @Path, @SourcePath, @BlurHash43, @BlurHash54, @BlurHash64)",
+                    parameters)
+                .ToUnit(),
+            _ => Task.FromResult(Unit.Default)
+        };
+    }
+
+    public Task<Unit> RemoveArtwork(Metadata metadata, ArtworkKind artworkKind) =>
+        _dbConnection.ExecuteAsync(
+            @"DELETE FROM Artwork WHERE ArtworkKind = @ArtworkKind AND (MovieMetadataId = @Id
+                OR ShowMetadataId = @Id OR SeasonMetadataId = @Id OR EpisodeMetadataId = @Id)",
+            new { ArtworkKind = artworkKind, metadata.Id }).ToUnit();
+
+    public async Task<bool> CloneArtwork(
+        Metadata metadata,
+        Option<Artwork> maybeArtwork,
+        ArtworkKind artworkKind,
+        string sourcePath,
+        DateTime lastWriteTime)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<Artwork> maybeExisting = await dbContext.Artwork
+            .AsNoTracking()
+            .Filter(
+                a => a.SourcePath == sourcePath && a.ArtworkKind == artworkKind && a.DateUpdated == lastWriteTime)
+            .FirstOrDefaultAsync()
+            .Map(Optional);
+        foreach (Artwork existing in maybeExisting)
+        {
+            Artwork artwork = await maybeArtwork.IfNoneAsync(new Artwork());
+            if (maybeArtwork.IsNone)
+            {
+                metadata.Artwork.Add(artwork);
             }
 
-            return false;
+            artwork.Path = existing.Path;
+            artwork.SourcePath = existing.SourcePath;
+            artwork.ArtworkKind = artworkKind;
+            artwork.BlurHash43 = existing.BlurHash43;
+            artwork.BlurHash54 = existing.BlurHash54;
+            artwork.BlurHash64 = existing.BlurHash64;
+            artwork.DateAdded = existing.DateAdded;
+            artwork.DateUpdated = existing.DateUpdated;
+
+            if (maybeArtwork.IsNone)
+            {
+                await AddArtwork(metadata, artwork);
+            }
+            else
+            {
+                await UpdateArtworkPath(artwork);
+            }
+
+            return true;
         }
 
-        public Task<Unit> MarkAsUpdated(ShowMetadata metadata, DateTime dateUpdated) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE ShowMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
-                new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
-
-        public Task<Unit> MarkAsUpdated(SeasonMetadata metadata, DateTime dateUpdated) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE SeasonMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
-                new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
-
-        public Task<Unit> MarkAsUpdated(MovieMetadata metadata, DateTime dateUpdated) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE MovieMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
-                new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
-
-        public Task<Unit> MarkAsUpdated(EpisodeMetadata metadata, DateTime dateUpdated) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE EpisodeMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
-                new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
-
-        public Task<Unit> MarkAsExternal(ShowMetadata metadata) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE ShowMetadata SET MetadataKind = @Kind WHERE Id = @Id",
-                new { metadata.Id, Kind = (int) MetadataKind.External }).ToUnit();
-
-        public Task<Unit> SetContentRating(ShowMetadata metadata, string contentRating) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE ShowMetadata SET ContentRating = @ContentRating WHERE Id = @Id",
-                new { metadata.Id, ContentRating = contentRating }).ToUnit();
-
-        public Task<Unit> MarkAsExternal(MovieMetadata metadata) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE MovieMetadata SET MetadataKind = @Kind WHERE Id = @Id",
-                new { metadata.Id, Kind = (int) MetadataKind.External }).ToUnit();
-
-        public Task<Unit> SetContentRating(MovieMetadata metadata, string contentRating) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE MovieMetadata SET ContentRating = @ContentRating WHERE Id = @Id",
-                new { metadata.Id, ContentRating = contentRating }).ToUnit();
-
-        public Task<bool> RemoveGuid(MetadataGuid guid) =>
-            _dbConnection.ExecuteAsync("DELETE FROM MetadataGuid WHERE Id = @GuidId", new { GuidId = guid.Id })
-                .Map(result => result > 0);
-
-        public Task<bool> AddGuid(Metadata metadata, MetadataGuid guid) =>
-            metadata switch
-            {
-                MovieMetadata =>
-                    _dbConnection.ExecuteAsync(
-                        "INSERT INTO MetadataGuid (Guid, MovieMetadataId) VALUES (@Guid, @MetadataId)",
-                        new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
-                ShowMetadata =>
-                    _dbConnection.ExecuteAsync(
-                        "INSERT INTO MetadataGuid (Guid, ShowMetadataId) VALUES (@Guid, @MetadataId)",
-                        new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
-                SeasonMetadata =>
-                    _dbConnection.ExecuteAsync(
-                        "INSERT INTO MetadataGuid (Guid, SeasonMetadataId) VALUES (@Guid, @MetadataId)",
-                        new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
-                EpisodeMetadata =>
-                    _dbConnection.ExecuteAsync(
-                        "INSERT INTO MetadataGuid (Guid, EpisodeMetadataId) VALUES (@Guid, @MetadataId)",
-                        new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
-                ArtistMetadata =>
-                    _dbConnection.ExecuteAsync(
-                        "INSERT INTO MetadataGuid (Guid, ArtistMetadataId) VALUES (@Guid, @MetadataId)",
-                        new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
-                _ => throw new NotSupportedException()
-            };
-
-        public Task<bool> RemoveDirector(Director director) =>
-            _dbConnection.ExecuteAsync("DELETE FROM Director WHERE Id = @DirectorId", new { DirectorId = director.Id })
-                .Map(result => result > 0);
-
-        public Task<bool> RemoveWriter(Writer writer) =>
-            _dbConnection.ExecuteAsync("DELETE FROM Writer WHERE Id = @WriterId", new { WriterId = writer.Id })
-                .Map(result => result > 0);
-
-        public Task<bool> RemoveGenre(Genre genre) =>
-            _dbConnection.ExecuteAsync("DELETE FROM Genre WHERE Id = @GenreId", new { GenreId = genre.Id })
-                .Map(result => result > 0);
-
-        public Task<bool> RemoveTag(Tag tag) =>
-            _dbConnection.ExecuteAsync("DELETE FROM Tag WHERE Id = @TagId", new { TagId = tag.Id })
-                .Map(result => result > 0);
-
-        public Task<bool> RemoveStudio(Studio studio) =>
-            _dbConnection.ExecuteAsync("DELETE FROM Studio WHERE Id = @StudioId", new { StudioId = studio.Id })
-                .Map(result => result > 0);
-
-        public Task<bool> RemoveStyle(Style style) =>
-            _dbConnection.ExecuteAsync("DELETE FROM Style WHERE Id = @StyleId", new { StyleId = style.Id })
-                .Map(result => result > 0);
-
-        public Task<bool> RemoveMood(Mood mood) =>
-            _dbConnection.ExecuteAsync("DELETE FROM Mood WHERE Id = @MoodId", new { MoodId = mood.Id })
-                .Map(result => result > 0);
+        return false;
     }
-}
+
+    public Task<Unit> MarkAsUpdated(ShowMetadata metadata, DateTime dateUpdated) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE ShowMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
+            new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
+
+    public Task<Unit> MarkAsUpdated(SeasonMetadata metadata, DateTime dateUpdated) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE SeasonMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
+            new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
+
+    public Task<Unit> MarkAsUpdated(MovieMetadata metadata, DateTime dateUpdated) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE MovieMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
+            new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
+
+    public Task<Unit> MarkAsUpdated(EpisodeMetadata metadata, DateTime dateUpdated) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE EpisodeMetadata SET DateUpdated = @DateUpdated WHERE Id = @Id",
+            new { DateUpdated = dateUpdated, metadata.Id }).ToUnit();
+
+    public Task<Unit> MarkAsExternal(ShowMetadata metadata) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE ShowMetadata SET MetadataKind = @Kind WHERE Id = @Id",
+            new { metadata.Id, Kind = (int) MetadataKind.External }).ToUnit();
+
+    public Task<Unit> SetContentRating(ShowMetadata metadata, string contentRating) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE ShowMetadata SET ContentRating = @ContentRating WHERE Id = @Id",
+            new { metadata.Id, ContentRating = contentRating }).ToUnit();
+
+    public Task<Unit> MarkAsExternal(MovieMetadata metadata) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE MovieMetadata SET MetadataKind = @Kind WHERE Id = @Id",
+            new { metadata.Id, Kind = (int) MetadataKind.External }).ToUnit();
+
+    public Task<Unit> SetContentRating(MovieMetadata metadata, string contentRating) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE MovieMetadata SET ContentRating = @ContentRating WHERE Id = @Id",
+            new { metadata.Id, ContentRating = contentRating }).ToUnit();
+
+    public Task<bool> RemoveGuid(MetadataGuid guid) =>
+        _dbConnection.ExecuteAsync("DELETE FROM MetadataGuid WHERE Id = @GuidId", new { GuidId = guid.Id })
+            .Map(result => result > 0);
+
+    public Task<bool> AddGuid(Metadata metadata, MetadataGuid guid) =>
+        metadata switch
+        {
+            MovieMetadata =>
+                _dbConnection.ExecuteAsync(
+                    "INSERT INTO MetadataGuid (Guid, MovieMetadataId) VALUES (@Guid, @MetadataId)",
+                    new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
+            ShowMetadata =>
+                _dbConnection.ExecuteAsync(
+                    "INSERT INTO MetadataGuid (Guid, ShowMetadataId) VALUES (@Guid, @MetadataId)",
+                    new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
+            SeasonMetadata =>
+                _dbConnection.ExecuteAsync(
+                    "INSERT INTO MetadataGuid (Guid, SeasonMetadataId) VALUES (@Guid, @MetadataId)",
+                    new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
+            EpisodeMetadata =>
+                _dbConnection.ExecuteAsync(
+                    "INSERT INTO MetadataGuid (Guid, EpisodeMetadataId) VALUES (@Guid, @MetadataId)",
+                    new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
+            ArtistMetadata =>
+                _dbConnection.ExecuteAsync(
+                    "INSERT INTO MetadataGuid (Guid, ArtistMetadataId) VALUES (@Guid, @MetadataId)",
+                    new { guid.Guid, MetadataId = metadata.Id }).Map(result => result > 0),
+            _ => throw new NotSupportedException()
+        };
+
+    public Task<bool> RemoveDirector(Director director) =>
+        _dbConnection.ExecuteAsync("DELETE FROM Director WHERE Id = @DirectorId", new { DirectorId = director.Id })
+            .Map(result => result > 0);
+
+    public Task<bool> RemoveWriter(Writer writer) =>
+        _dbConnection.ExecuteAsync("DELETE FROM Writer WHERE Id = @WriterId", new { WriterId = writer.Id })
+            .Map(result => result > 0);
+
+    public Task<bool> RemoveGenre(Genre genre) =>
+        _dbConnection.ExecuteAsync("DELETE FROM Genre WHERE Id = @GenreId", new { GenreId = genre.Id })
+            .Map(result => result > 0);
+
+    public Task<bool> RemoveTag(Tag tag) =>
+        _dbConnection.ExecuteAsync("DELETE FROM Tag WHERE Id = @TagId", new { TagId = tag.Id })
+            .Map(result => result > 0);
+
+    public Task<bool> RemoveStudio(Studio studio) =>
+        _dbConnection.ExecuteAsync("DELETE FROM Studio WHERE Id = @StudioId", new { StudioId = studio.Id })
+            .Map(result => result > 0);
+
+    public Task<bool> RemoveStyle(Style style) =>
+        _dbConnection.ExecuteAsync("DELETE FROM Style WHERE Id = @StyleId", new { StyleId = style.Id })
+            .Map(result => result > 0);
+
+    public Task<bool> RemoveMood(Mood mood) =>
+        _dbConnection.ExecuteAsync("DELETE FROM Mood WHERE Id = @MoodId", new { MoodId = mood.Id })
+            .Map(result => result > 0);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/MovieRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/MovieRepository.cs
index 09f0dd54d..676f13c65 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/MovieRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/MovieRepository.cs
@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
@@ -10,834 +6,830 @@ using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Jellyfin;
 using ErsatzTV.Core.Metadata;
-using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class MovieRepository : IMovieRepository
 {
-    public class MovieRepository : IMovieRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public MovieRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public MovieRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public Task<bool> AllMoviesExist(List<int> movieIds) =>
+        _dbConnection.QuerySingleAsync<int>(
+                "SELECT COUNT(*) FROM Movie WHERE Id in @MovieIds",
+                new { MovieIds = movieIds })
+            .Map(c => c == movieIds.Count);
 
-        public Task<bool> AllMoviesExist(List<int> movieIds) =>
-            _dbConnection.QuerySingleAsync<int>(
-                    "SELECT COUNT(*) FROM Movie WHERE Id in @MovieIds",
-                    new { MovieIds = movieIds })
-                .Map(c => c == movieIds.Count);
+    public async Task<Option<Movie>> GetMovie(int movieId)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.Movies
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(m => m.Artwork)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(m => m.Genres)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(m => m.Tags)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(m => m.Studios)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(m => m.Actors)
+            .ThenInclude(a => a.Artwork)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .OrderBy(m => m.Id)
+            .SingleOrDefaultAsync(m => m.Id == movieId)
+            .Map(Optional);
+    }
 
-        public async Task<Option<Movie>> GetMovie(int movieId)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.Movies
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(m => m.Artwork)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(m => m.Genres)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(m => m.Tags)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(m => m.Studios)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(m => m.Actors)
-                .ThenInclude(a => a.Artwork)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .OrderBy(m => m.Id)
-                .SingleOrDefaultAsync(m => m.Id == movieId)
-                .Map(Optional);
-        }
+    public async Task<Either<BaseError, MediaItemScanResult<Movie>>> GetOrAdd(LibraryPath libraryPath, string path)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<Movie> maybeExisting = await dbContext.Movies
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .ThenInclude(a => a.Artwork)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(i => i.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(i => i.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(i => i.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(i => i.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(i => i.MediaVersions.First().MediaFiles.First().Path)
+            .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
 
-        public async Task<Either<BaseError, MediaItemScanResult<Movie>>> GetOrAdd(LibraryPath libraryPath, string path)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<Movie> maybeExisting = await dbContext.Movies
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .ThenInclude(a => a.Artwork)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(i => i.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(i => i.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(i => i.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(i => i.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(i => i.MediaVersions.First().MediaFiles.First().Path)
-                .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
+        return await maybeExisting.Match(
+            mediaItem =>
+                Right<BaseError, MediaItemScanResult<Movie>>(
+                    new MediaItemScanResult<Movie>(mediaItem) { IsAdded = false }).AsTask(),
+            async () => await AddMovie(dbContext, libraryPath.Id, path));
+    }
 
-            return await maybeExisting.Match(
-                mediaItem =>
-                    Right<BaseError, MediaItemScanResult<Movie>>(
-                        new MediaItemScanResult<Movie>(mediaItem) { IsAdded = false }).AsTask(),
-                async () => await AddMovie(dbContext, libraryPath.Id, path));
-        }
+    public async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> GetOrAdd(
+        PlexLibrary library,
+        PlexMovie item)
+    {
+        await using TvContext context = _dbContextFactory.CreateDbContext();
+        Option<PlexMovie> maybeExisting = await context.PlexMovies
+            .AsNoTracking()
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .ThenInclude(a => a.Artwork)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(i => i.MovieMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(i => i.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(i => i.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(i => i.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(i => i.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(i => i.Key)
+            .SingleOrDefaultAsync(i => i.Key == item.Key);
 
-        public async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> GetOrAdd(
-            PlexLibrary library,
-            PlexMovie item)
-        {
-            await using TvContext context = _dbContextFactory.CreateDbContext();
-            Option<PlexMovie> maybeExisting = await context.PlexMovies
-                .AsNoTracking()
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .ThenInclude(a => a.Artwork)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(i => i.MovieMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(i => i.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(i => i.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(i => i.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(i => i.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(i => i.Key)
-                .SingleOrDefaultAsync(i => i.Key == item.Key);
+        return await maybeExisting.Match(
+            plexMovie =>
+                Right<BaseError, MediaItemScanResult<PlexMovie>>(
+                    new MediaItemScanResult<PlexMovie>(plexMovie) { IsAdded = false }).AsTask(),
+            async () => await AddPlexMovie(context, library, item));
+    }
 
-            return await maybeExisting.Match(
-                plexMovie =>
-                    Right<BaseError, MediaItemScanResult<PlexMovie>>(
-                        new MediaItemScanResult<PlexMovie>(plexMovie) { IsAdded = false }).AsTask(),
-                async () => await AddPlexMovie(context, library, item));
-        }
+    public async Task<List<MovieMetadata>> GetMoviesForCards(List<int> ids)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.MovieMetadata
+            .AsNoTracking()
+            .Filter(mm => ids.Contains(mm.MovieId))
+            .Include(mm => mm.Artwork)
+            .Include(mm => mm.Movie)
+            .ThenInclude(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .OrderBy(mm => mm.SortTitle)
+            .ToListAsync();
+    }
 
-        public async Task<List<MovieMetadata>> GetMoviesForCards(List<int> ids)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.MovieMetadata
-                .AsNoTracking()
-                .Filter(mm => ids.Contains(mm.MovieId))
-                .Include(mm => mm.Artwork)
-                .Include(mm => mm.Movie)
-                .ThenInclude(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .OrderBy(mm => mm.SortTitle)
-                .ToListAsync();
-        }
-
-        public Task<IEnumerable<string>> FindMoviePaths(LibraryPath libraryPath) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT MF.Path
+    public Task<IEnumerable<string>> FindMoviePaths(LibraryPath libraryPath) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT MF.Path
                 FROM MediaFile MF
                 INNER JOIN MediaVersion MV on MF.MediaVersionId = MV.Id
                 INNER JOIN Movie M on MV.MovieId = M.Id
                 INNER JOIN MediaItem MI on M.Id = MI.Id
                 WHERE MI.LibraryPathId = @LibraryPathId",
-                new { LibraryPathId = libraryPath.Id });
+            new { LibraryPathId = libraryPath.Id });
 
-        public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                    @"SELECT M.Id
+    public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+                @"SELECT M.Id
                 FROM Movie M
                 INNER JOIN MediaItem MI on M.Id = MI.Id
                 INNER JOIN MediaVersion MV on M.Id = MV.MovieId
                 INNER JOIN MediaFile MF on MV.Id = MF.MediaVersionId
                 WHERE MI.LibraryPathId = @LibraryPathId AND MF.Path = @Path",
-                    new { LibraryPathId = libraryPath.Id, Path = path })
-                .Map(result => result.ToList());
+                new { LibraryPathId = libraryPath.Id, Path = path })
+            .Map(result => result.ToList());
 
-            foreach (int movieId in ids)
-            {
-                Movie movie = await dbContext.Movies.FindAsync(movieId);
-                if (movie != null)
-                {
-                    dbContext.Movies.Remove(movie);
-                }
-            }
-
-            bool changed = await dbContext.SaveChangesAsync() > 0;
-            return changed ? ids : new List<int>();
-        }
-        
-        public Task<bool> AddGenre(MovieMetadata metadata, Genre genre) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Genre (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
-                new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddTag(MovieMetadata metadata, Tag tag) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Tag (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
-                new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddStudio(MovieMetadata metadata, Studio studio) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Studio (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
-                new { studio.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public async Task<bool> AddActor(MovieMetadata metadata, Actor actor)
+        foreach (int movieId in ids)
         {
-            int? artworkId = null;
-
-            if (actor.Artwork != null)
+            Movie movie = await dbContext.Movies.FindAsync(movieId);
+            if (movie != null)
             {
-                artworkId = await _dbConnection.QuerySingleAsync<int>(
-                    @"INSERT INTO Artwork (ArtworkKind, DateAdded, DateUpdated, Path)
+                dbContext.Movies.Remove(movie);
+            }
+        }
+
+        bool changed = await dbContext.SaveChangesAsync() > 0;
+        return changed ? ids : new List<int>();
+    }
+        
+    public Task<bool> AddGenre(MovieMetadata metadata, Genre genre) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Genre (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
+            new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddTag(MovieMetadata metadata, Tag tag) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Tag (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
+            new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddStudio(MovieMetadata metadata, Studio studio) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Studio (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
+            new { studio.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public async Task<bool> AddActor(MovieMetadata metadata, Actor actor)
+    {
+        int? artworkId = null;
+
+        if (actor.Artwork != null)
+        {
+            artworkId = await _dbConnection.QuerySingleAsync<int>(
+                @"INSERT INTO Artwork (ArtworkKind, DateAdded, DateUpdated, Path)
                       VALUES (@ArtworkKind, @DateAdded, @DateUpdated, @Path);
                       SELECT last_insert_rowid()",
-                    new
-                    {
-                        ArtworkKind = (int) actor.Artwork.ArtworkKind,
-                        actor.Artwork.DateAdded,
-                        actor.Artwork.DateUpdated,
-                        actor.Artwork.Path
-                    });
-            }
-
-            return await _dbConnection.ExecuteAsync(
-                    "INSERT INTO Actor (Name, Role, \"Order\", MovieMetadataId, ArtworkId) VALUES (@Name, @Role, @Order, @MetadataId, @ArtworkId)",
-                    new { actor.Name, actor.Role, actor.Order, MetadataId = metadata.Id, ArtworkId = artworkId })
-                .Map(result => result > 0);
+                new
+                {
+                    ArtworkKind = (int) actor.Artwork.ArtworkKind,
+                    actor.Artwork.DateAdded,
+                    actor.Artwork.DateUpdated,
+                    actor.Artwork.Path
+                });
         }
 
-        public async Task<List<int>> RemoveMissingPlexMovies(PlexLibrary library, List<string> movieKeys)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        return await _dbConnection.ExecuteAsync(
+                "INSERT INTO Actor (Name, Role, \"Order\", MovieMetadataId, ArtworkId) VALUES (@Name, @Role, @Order, @MetadataId, @ArtworkId)",
+                new { actor.Name, actor.Role, actor.Order, MetadataId = metadata.Id, ArtworkId = artworkId })
+            .Map(result => result > 0);
+    }
+
+    public async Task<List<int>> RemoveMissingPlexMovies(PlexLibrary library, List<string> movieKeys)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexMovie pm ON pm.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 WHERE lp.LibraryId = @LibraryId AND pm.Key not in @Keys",
-                new { LibraryId = library.Id, Keys = movieKeys }).Map(result => result.ToList());
+            new { LibraryId = library.Id, Keys = movieKeys }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
-        }
+        return ids;
+    }
 
-        public Task<bool> UpdateSortTitle(MovieMetadata movieMetadata) =>
-            _dbConnection.ExecuteAsync(
-                @"UPDATE MovieMetadata SET SortTitle = @SortTitle WHERE Id = @Id",
-                new { movieMetadata.SortTitle, movieMetadata.Id }).Map(result => result > 0);
+    public Task<bool> UpdateSortTitle(MovieMetadata movieMetadata) =>
+        _dbConnection.ExecuteAsync(
+            @"UPDATE MovieMetadata SET SortTitle = @SortTitle WHERE Id = @Id",
+            new { movieMetadata.SortTitle, movieMetadata.Id }).Map(result => result > 0);
 
-        public Task<List<JellyfinItemEtag>> GetExistingJellyfinMovies(JellyfinLibrary library) =>
-            _dbConnection.QueryAsync<JellyfinItemEtag>(
-                    @"SELECT ItemId, Etag FROM JellyfinMovie
+    public Task<List<JellyfinItemEtag>> GetExistingJellyfinMovies(JellyfinLibrary library) =>
+        _dbConnection.QueryAsync<JellyfinItemEtag>(
+                @"SELECT ItemId, Etag FROM JellyfinMovie
                       INNER JOIN Movie M on JellyfinMovie.Id = M.Id
                       INNER JOIN MediaItem MI on M.Id = MI.Id
                       INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                       WHERE LP.LibraryId = @LibraryId",
-                    new { LibraryId = library.Id })
-                .Map(result => result.ToList());
+                new { LibraryId = library.Id })
+            .Map(result => result.ToList());
 
-        public async Task<List<int>> RemoveMissingJellyfinMovies(JellyfinLibrary library, List<string> movieIds)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT JellyfinMovie.Id FROM JellyfinMovie
+    public async Task<List<int>> RemoveMissingJellyfinMovies(JellyfinLibrary library, List<string> movieIds)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT JellyfinMovie.Id FROM JellyfinMovie
                   INNER JOIN Movie M on JellyfinMovie.Id = M.Id
                   INNER JOIN MediaItem MI on M.Id = MI.Id
                   INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                   WHERE LP.LibraryId = @LibraryId AND ItemId IN @ItemIds",
-                new { LibraryId = library.Id, ItemIds = movieIds }).Map(result => result.ToList());
+            new { LibraryId = library.Id, ItemIds = movieIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
+        return ids;
+    }
+
+    public async Task<bool> AddJellyfin(JellyfinMovie movie)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await dbContext.AddAsync(movie);
+        if (await dbContext.SaveChangesAsync() <= 0)
+        {
+            return false;
         }
 
-        public async Task<bool> AddJellyfin(JellyfinMovie movie)
+        await dbContext.Entry(movie).Reference(m => m.LibraryPath).LoadAsync();
+        await dbContext.Entry(movie.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+        return true;
+    }
+
+    public async Task<Option<JellyfinMovie>> UpdateJellyfin(JellyfinMovie movie)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<JellyfinMovie> maybeExisting = await dbContext.JellyfinMovies
+            .Include(m => m.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(m => m.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .Filter(m => m.ItemId == movie.ItemId)
+            .OrderBy(m => m.ItemId)
+            .SingleOrDefaultAsync();
+
+        if (maybeExisting.IsSome)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            await dbContext.AddAsync(movie);
-            if (await dbContext.SaveChangesAsync() <= 0)
+            JellyfinMovie existing = maybeExisting.ValueUnsafe();
+
+            // library path is used for search indexing later
+            movie.LibraryPath = existing.LibraryPath;
+            movie.Id = existing.Id;
+
+            existing.Etag = movie.Etag;
+
+            // metadata
+            MovieMetadata metadata = existing.MovieMetadata.Head();
+            MovieMetadata incomingMetadata = movie.MovieMetadata.Head();
+            metadata.MetadataKind = incomingMetadata.MetadataKind;
+            metadata.ContentRating = incomingMetadata.ContentRating;
+            metadata.Title = incomingMetadata.Title;
+            metadata.SortTitle = incomingMetadata.SortTitle;
+            metadata.Plot = incomingMetadata.Plot;
+            metadata.Year = incomingMetadata.Year;
+            metadata.Tagline = incomingMetadata.Tagline;
+            metadata.DateAdded = incomingMetadata.DateAdded;
+            metadata.DateUpdated = DateTime.UtcNow;
+
+            // genres
+            foreach (Genre genre in metadata.Genres
+                         .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
             {
-                return false;
+                metadata.Genres.Remove(genre);
             }
 
-            await dbContext.Entry(movie).Reference(m => m.LibraryPath).LoadAsync();
-            await dbContext.Entry(movie.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-            return true;
-        }
-
-        public async Task<Option<JellyfinMovie>> UpdateJellyfin(JellyfinMovie movie)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<JellyfinMovie> maybeExisting = await dbContext.JellyfinMovies
-                .Include(m => m.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(m => m.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .Filter(m => m.ItemId == movie.ItemId)
-                .OrderBy(m => m.ItemId)
-                .SingleOrDefaultAsync();
-
-            if (maybeExisting.IsSome)
+            foreach (Genre genre in incomingMetadata.Genres
+                         .Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
             {
-                JellyfinMovie existing = maybeExisting.ValueUnsafe();
-
-                // library path is used for search indexing later
-                movie.LibraryPath = existing.LibraryPath;
-                movie.Id = existing.Id;
-
-                existing.Etag = movie.Etag;
-
-                // metadata
-                MovieMetadata metadata = existing.MovieMetadata.Head();
-                MovieMetadata incomingMetadata = movie.MovieMetadata.Head();
-                metadata.MetadataKind = incomingMetadata.MetadataKind;
-                metadata.ContentRating = incomingMetadata.ContentRating;
-                metadata.Title = incomingMetadata.Title;
-                metadata.SortTitle = incomingMetadata.SortTitle;
-                metadata.Plot = incomingMetadata.Plot;
-                metadata.Year = incomingMetadata.Year;
-                metadata.Tagline = incomingMetadata.Tagline;
-                metadata.DateAdded = incomingMetadata.DateAdded;
-                metadata.DateUpdated = DateTime.UtcNow;
-
-                // genres
-                foreach (Genre genre in metadata.Genres
-                    .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Genres.Remove(genre);
-                }
-
-                foreach (Genre genre in incomingMetadata.Genres
-                    .Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Genres.Add(genre);
-                }
-
-                // tags
-                foreach (Tag tag in metadata.Tags
-                    .Filter(g => incomingMetadata.Tags.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Tags.Remove(tag);
-                }
-
-                foreach (Tag tag in incomingMetadata.Tags
-                    .Filter(g => metadata.Tags.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Tags.Add(tag);
-                }
-
-                // studios
-                foreach (Studio studio in metadata.Studios
-                    .Filter(g => incomingMetadata.Studios.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Studios.Remove(studio);
-                }
-
-                foreach (Studio studio in incomingMetadata.Studios
-                    .Filter(g => metadata.Studios.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Studios.Add(studio);
-                }
-
-                // actors
-                foreach (Actor actor in metadata.Actors
-                    .Filter(
-                        a => incomingMetadata.Actors.All(
-                            a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
-                    .ToList())
-                {
-                    metadata.Actors.Remove(actor);
-                }
-
-                foreach (Actor actor in incomingMetadata.Actors
-                    .Filter(a => metadata.Actors.All(a2 => a2.Name != a.Name))
-                    .ToList())
-                {
-                    metadata.Actors.Add(actor);
-                }
-
-                // directors
-                foreach (Director director in metadata.Directors
-                    .Filter(d => incomingMetadata.Directors.All(d2 => d2.Name != d.Name))
-                    .ToList())
-                {
-                    metadata.Directors.Remove(director);
-                }
-
-                foreach (Director director in incomingMetadata.Directors
-                    .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name))
-                    .ToList())
-                {
-                    metadata.Directors.Add(director);
-                }
-
-                // writers
-                foreach (Writer writer in metadata.Writers
-                    .Filter(w => incomingMetadata.Writers.All(w2 => w2.Name != w.Name))
-                    .ToList())
-                {
-                    metadata.Writers.Remove(writer);
-                }
-
-                foreach (Writer writer in incomingMetadata.Writers
-                    .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name))
-                    .ToList())
-                {
-                    metadata.Writers.Add(writer);
-                }
-
-                // guids
-                foreach (MetadataGuid guid in metadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Remove(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Add(guid);
-                }
-
-                metadata.ReleaseDate = incomingMetadata.ReleaseDate;
-
-                // poster
-                Artwork incomingPoster =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                if (incomingPoster != null)
-                {
-                    Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                    if (poster == null)
-                    {
-                        poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
-                        metadata.Artwork.Add(poster);
-                    }
-
-                    poster.Path = incomingPoster.Path;
-                    poster.DateAdded = incomingPoster.DateAdded;
-                    poster.DateUpdated = incomingPoster.DateUpdated;
-                }
-
-                // fan art
-                Artwork incomingFanArt =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                if (incomingFanArt != null)
-                {
-                    Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                    if (fanArt == null)
-                    {
-                        fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
-                        metadata.Artwork.Add(fanArt);
-                    }
-
-                    fanArt.Path = incomingFanArt.Path;
-                    fanArt.DateAdded = incomingFanArt.DateAdded;
-                    fanArt.DateUpdated = incomingFanArt.DateUpdated;
-                }
-
-                // version
-                MediaVersion version = existing.MediaVersions.Head();
-                MediaVersion incomingVersion = movie.MediaVersions.Head();
-                version.Name = incomingVersion.Name;
-                version.DateAdded = incomingVersion.DateAdded;
-
-                // media file
-                MediaFile file = version.MediaFiles.Head();
-                MediaFile incomingFile = incomingVersion.MediaFiles.Head();
-                file.Path = incomingFile.Path;
+                metadata.Genres.Add(genre);
             }
 
-            await dbContext.SaveChangesAsync();
+            // tags
+            foreach (Tag tag in metadata.Tags
+                         .Filter(g => incomingMetadata.Tags.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Tags.Remove(tag);
+            }
 
-            return maybeExisting;
+            foreach (Tag tag in incomingMetadata.Tags
+                         .Filter(g => metadata.Tags.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Tags.Add(tag);
+            }
+
+            // studios
+            foreach (Studio studio in metadata.Studios
+                         .Filter(g => incomingMetadata.Studios.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Studios.Remove(studio);
+            }
+
+            foreach (Studio studio in incomingMetadata.Studios
+                         .Filter(g => metadata.Studios.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Studios.Add(studio);
+            }
+
+            // actors
+            foreach (Actor actor in metadata.Actors
+                         .Filter(
+                             a => incomingMetadata.Actors.All(
+                                 a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
+                         .ToList())
+            {
+                metadata.Actors.Remove(actor);
+            }
+
+            foreach (Actor actor in incomingMetadata.Actors
+                         .Filter(a => metadata.Actors.All(a2 => a2.Name != a.Name))
+                         .ToList())
+            {
+                metadata.Actors.Add(actor);
+            }
+
+            // directors
+            foreach (Director director in metadata.Directors
+                         .Filter(d => incomingMetadata.Directors.All(d2 => d2.Name != d.Name))
+                         .ToList())
+            {
+                metadata.Directors.Remove(director);
+            }
+
+            foreach (Director director in incomingMetadata.Directors
+                         .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name))
+                         .ToList())
+            {
+                metadata.Directors.Add(director);
+            }
+
+            // writers
+            foreach (Writer writer in metadata.Writers
+                         .Filter(w => incomingMetadata.Writers.All(w2 => w2.Name != w.Name))
+                         .ToList())
+            {
+                metadata.Writers.Remove(writer);
+            }
+
+            foreach (Writer writer in incomingMetadata.Writers
+                         .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name))
+                         .ToList())
+            {
+                metadata.Writers.Add(writer);
+            }
+
+            // guids
+            foreach (MetadataGuid guid in metadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Remove(guid);
+            }
+
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Add(guid);
+            }
+
+            metadata.ReleaseDate = incomingMetadata.ReleaseDate;
+
+            // poster
+            Artwork incomingPoster =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+            if (incomingPoster != null)
+            {
+                Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+                if (poster == null)
+                {
+                    poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
+                    metadata.Artwork.Add(poster);
+                }
+
+                poster.Path = incomingPoster.Path;
+                poster.DateAdded = incomingPoster.DateAdded;
+                poster.DateUpdated = incomingPoster.DateUpdated;
+            }
+
+            // fan art
+            Artwork incomingFanArt =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+            if (incomingFanArt != null)
+            {
+                Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+                if (fanArt == null)
+                {
+                    fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
+                    metadata.Artwork.Add(fanArt);
+                }
+
+                fanArt.Path = incomingFanArt.Path;
+                fanArt.DateAdded = incomingFanArt.DateAdded;
+                fanArt.DateUpdated = incomingFanArt.DateUpdated;
+            }
+
+            // version
+            MediaVersion version = existing.MediaVersions.Head();
+            MediaVersion incomingVersion = movie.MediaVersions.Head();
+            version.Name = incomingVersion.Name;
+            version.DateAdded = incomingVersion.DateAdded;
+
+            // media file
+            MediaFile file = version.MediaFiles.Head();
+            MediaFile incomingFile = incomingVersion.MediaFiles.Head();
+            file.Path = incomingFile.Path;
         }
 
-        public Task<List<EmbyItemEtag>> GetExistingEmbyMovies(EmbyLibrary library) =>
-            _dbConnection.QueryAsync<EmbyItemEtag>(
-                    @"SELECT ItemId, Etag FROM EmbyMovie
+        await dbContext.SaveChangesAsync();
+
+        return maybeExisting;
+    }
+
+    public Task<List<EmbyItemEtag>> GetExistingEmbyMovies(EmbyLibrary library) =>
+        _dbConnection.QueryAsync<EmbyItemEtag>(
+                @"SELECT ItemId, Etag FROM EmbyMovie
                       INNER JOIN Movie M on EmbyMovie.Id = M.Id
                       INNER JOIN MediaItem MI on M.Id = MI.Id
                       INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                       WHERE LP.LibraryId = @LibraryId",
-                    new { LibraryId = library.Id })
-                .Map(result => result.ToList());
+                new { LibraryId = library.Id })
+            .Map(result => result.ToList());
 
-        public async Task<List<int>> RemoveMissingEmbyMovies(EmbyLibrary library, List<string> movieIds)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT EmbyMovie.Id FROM EmbyMovie
+    public async Task<List<int>> RemoveMissingEmbyMovies(EmbyLibrary library, List<string> movieIds)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT EmbyMovie.Id FROM EmbyMovie
                   INNER JOIN Movie M on EmbyMovie.Id = M.Id
                   INNER JOIN MediaItem MI on M.Id = MI.Id
                   INNER JOIN LibraryPath LP on MI.LibraryPathId = LP.Id
                   WHERE LP.LibraryId = @LibraryId AND ItemId IN @ItemIds",
-                new { LibraryId = library.Id, ItemIds = movieIds }).Map(result => result.ToList());
+            new { LibraryId = library.Id, ItemIds = movieIds }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
+        return ids;
+    }
+
+    public async Task<bool> AddEmby(EmbyMovie movie)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        await dbContext.AddAsync(movie);
+        if (await dbContext.SaveChangesAsync() <= 0)
+        {
+            return false;
         }
 
-        public async Task<bool> AddEmby(EmbyMovie movie)
+        await dbContext.Entry(movie).Reference(m => m.LibraryPath).LoadAsync();
+        await dbContext.Entry(movie.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+        return true;
+    }
+
+    public async Task<Option<EmbyMovie>> UpdateEmby(EmbyMovie movie)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<EmbyMovie> maybeExisting = await dbContext.EmbyMovies
+            .Include(m => m.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(m => m.MovieMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Filter(m => m.ItemId == movie.ItemId)
+            .Include(m => m.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(m => m.ItemId)
+            .SingleOrDefaultAsync();
+
+        if (maybeExisting.IsSome)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            await dbContext.AddAsync(movie);
-            if (await dbContext.SaveChangesAsync() <= 0)
+            EmbyMovie existing = maybeExisting.ValueUnsafe();
+
+            // library path is used for search indexing later
+            movie.LibraryPath = existing.LibraryPath;
+            movie.Id = existing.Id;
+
+            existing.Etag = movie.Etag;
+
+            // metadata
+            MovieMetadata metadata = existing.MovieMetadata.Head();
+            MovieMetadata incomingMetadata = movie.MovieMetadata.Head();
+            metadata.MetadataKind = incomingMetadata.MetadataKind;
+            metadata.ContentRating = incomingMetadata.ContentRating;
+            metadata.Title = incomingMetadata.Title;
+            metadata.SortTitle = incomingMetadata.SortTitle;
+            metadata.Plot = incomingMetadata.Plot;
+            metadata.Year = incomingMetadata.Year;
+            metadata.Tagline = incomingMetadata.Tagline;
+            metadata.DateAdded = incomingMetadata.DateAdded;
+            metadata.DateUpdated = DateTime.UtcNow;
+
+            // genres
+            foreach (Genre genre in metadata.Genres
+                         .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
             {
-                return false;
+                metadata.Genres.Remove(genre);
             }
 
+            foreach (Genre genre in incomingMetadata.Genres
+                         .Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Genres.Add(genre);
+            }
+
+            // tags
+            foreach (Tag tag in metadata.Tags
+                         .Filter(g => incomingMetadata.Tags.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Tags.Remove(tag);
+            }
+
+            foreach (Tag tag in incomingMetadata.Tags
+                         .Filter(g => metadata.Tags.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Tags.Add(tag);
+            }
+
+            // studios
+            foreach (Studio studio in metadata.Studios
+                         .Filter(g => incomingMetadata.Studios.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Studios.Remove(studio);
+            }
+
+            foreach (Studio studio in incomingMetadata.Studios
+                         .Filter(g => metadata.Studios.All(g2 => g2.Name != g.Name))
+                         .ToList())
+            {
+                metadata.Studios.Add(studio);
+            }
+
+            // actors
+            foreach (Actor actor in metadata.Actors
+                         .Filter(
+                             a => incomingMetadata.Actors.All(
+                                 a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
+                         .ToList())
+            {
+                metadata.Actors.Remove(actor);
+            }
+
+            foreach (Actor actor in incomingMetadata.Actors
+                         .Filter(a => metadata.Actors.All(a2 => a2.Name != a.Name))
+                         .ToList())
+            {
+                metadata.Actors.Add(actor);
+            }
+
+            // directors
+            foreach (Director director in metadata.Directors
+                         .Filter(d => incomingMetadata.Directors.All(d2 => d2.Name != d.Name))
+                         .ToList())
+            {
+                metadata.Directors.Remove(director);
+            }
+
+            foreach (Director director in incomingMetadata.Directors
+                         .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name))
+                         .ToList())
+            {
+                metadata.Directors.Add(director);
+            }
+
+            // writers
+            foreach (Writer writer in metadata.Writers
+                         .Filter(w => incomingMetadata.Writers.All(w2 => w2.Name != w.Name))
+                         .ToList())
+            {
+                metadata.Writers.Remove(writer);
+            }
+
+            foreach (Writer writer in incomingMetadata.Writers
+                         .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name))
+                         .ToList())
+            {
+                metadata.Writers.Add(writer);
+            }
+
+            // guids
+            foreach (MetadataGuid guid in metadata.Guids
+                         .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Remove(guid);
+            }
+
+            foreach (MetadataGuid guid in incomingMetadata.Guids
+                         .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
+                         .ToList())
+            {
+                metadata.Guids.Add(guid);
+            }
+
+            metadata.ReleaseDate = incomingMetadata.ReleaseDate;
+
+            // poster
+            Artwork incomingPoster =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+            if (incomingPoster != null)
+            {
+                Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
+                if (poster == null)
+                {
+                    poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
+                    metadata.Artwork.Add(poster);
+                }
+
+                poster.Path = incomingPoster.Path;
+                poster.DateAdded = incomingPoster.DateAdded;
+                poster.DateUpdated = incomingPoster.DateUpdated;
+            }
+
+            // fan art
+            Artwork incomingFanArt =
+                incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+            if (incomingFanArt != null)
+            {
+                Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
+                if (fanArt == null)
+                {
+                    fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
+                    metadata.Artwork.Add(fanArt);
+                }
+
+                fanArt.Path = incomingFanArt.Path;
+                fanArt.DateAdded = incomingFanArt.DateAdded;
+                fanArt.DateUpdated = incomingFanArt.DateUpdated;
+            }
+
+            // version
+            MediaVersion version = existing.MediaVersions.Head();
+            MediaVersion incomingVersion = movie.MediaVersions.Head();
+            version.Name = incomingVersion.Name;
+            version.DateAdded = incomingVersion.DateAdded;
+
+            // media file
+            MediaFile file = version.MediaFiles.Head();
+            MediaFile incomingFile = incomingVersion.MediaFiles.Head();
+            file.Path = incomingFile.Path;
+        }
+
+        await dbContext.SaveChangesAsync();
+
+        return maybeExisting;
+    }
+
+    public Task<bool> AddDirector(MovieMetadata metadata, Director director) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Director (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
+            new { director.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddWriter(MovieMetadata metadata, Writer writer) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Writer (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
+            new { writer.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<Unit> UpdatePath(int mediaFileId, string path) =>
+        _dbConnection.ExecuteAsync(
+            "UPDATE MediaFile SET Path = @Path WHERE Id = @MediaFileId",
+            new { Path = path, MediaFileId = mediaFileId }).Map(_ => Unit.Default);
+
+    private static async Task<Either<BaseError, MediaItemScanResult<Movie>>> AddMovie(
+        TvContext dbContext,
+        int libraryPathId,
+        string path)
+    {
+        try
+        {
+            var movie = new Movie
+            {
+                LibraryPathId = libraryPathId,
+                MediaVersions = new List<MediaVersion>
+                {
+                    new()
+                    {
+                        MediaFiles = new List<MediaFile>
+                        {
+                            new() { Path = path }
+                        },
+                        Streams = new List<MediaStream>()
+                    }
+                },
+                TraktListItems = new List<TraktListItem>()
+            };
+            await dbContext.Movies.AddAsync(movie);
+            await dbContext.SaveChangesAsync();
             await dbContext.Entry(movie).Reference(m => m.LibraryPath).LoadAsync();
             await dbContext.Entry(movie.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-            return true;
+            return new MediaItemScanResult<Movie>(movie) { IsAdded = true };
         }
-
-        public async Task<Option<EmbyMovie>> UpdateEmby(EmbyMovie movie)
+        catch (Exception ex)
         {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<EmbyMovie> maybeExisting = await dbContext.EmbyMovies
-                .Include(m => m.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(m => m.MovieMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Filter(m => m.ItemId == movie.ItemId)
-                .Include(m => m.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(m => m.ItemId)
-                .SingleOrDefaultAsync();
-
-            if (maybeExisting.IsSome)
-            {
-                EmbyMovie existing = maybeExisting.ValueUnsafe();
-
-                // library path is used for search indexing later
-                movie.LibraryPath = existing.LibraryPath;
-                movie.Id = existing.Id;
-
-                existing.Etag = movie.Etag;
-
-                // metadata
-                MovieMetadata metadata = existing.MovieMetadata.Head();
-                MovieMetadata incomingMetadata = movie.MovieMetadata.Head();
-                metadata.MetadataKind = incomingMetadata.MetadataKind;
-                metadata.ContentRating = incomingMetadata.ContentRating;
-                metadata.Title = incomingMetadata.Title;
-                metadata.SortTitle = incomingMetadata.SortTitle;
-                metadata.Plot = incomingMetadata.Plot;
-                metadata.Year = incomingMetadata.Year;
-                metadata.Tagline = incomingMetadata.Tagline;
-                metadata.DateAdded = incomingMetadata.DateAdded;
-                metadata.DateUpdated = DateTime.UtcNow;
-
-                // genres
-                foreach (Genre genre in metadata.Genres
-                    .Filter(g => incomingMetadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Genres.Remove(genre);
-                }
-
-                foreach (Genre genre in incomingMetadata.Genres
-                    .Filter(g => metadata.Genres.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Genres.Add(genre);
-                }
-
-                // tags
-                foreach (Tag tag in metadata.Tags
-                    .Filter(g => incomingMetadata.Tags.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Tags.Remove(tag);
-                }
-
-                foreach (Tag tag in incomingMetadata.Tags
-                    .Filter(g => metadata.Tags.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Tags.Add(tag);
-                }
-
-                // studios
-                foreach (Studio studio in metadata.Studios
-                    .Filter(g => incomingMetadata.Studios.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Studios.Remove(studio);
-                }
-
-                foreach (Studio studio in incomingMetadata.Studios
-                    .Filter(g => metadata.Studios.All(g2 => g2.Name != g.Name))
-                    .ToList())
-                {
-                    metadata.Studios.Add(studio);
-                }
-
-                // actors
-                foreach (Actor actor in metadata.Actors
-                    .Filter(
-                        a => incomingMetadata.Actors.All(
-                            a2 => a2.Name != a.Name || a.Artwork == null && a2.Artwork != null))
-                    .ToList())
-                {
-                    metadata.Actors.Remove(actor);
-                }
-
-                foreach (Actor actor in incomingMetadata.Actors
-                    .Filter(a => metadata.Actors.All(a2 => a2.Name != a.Name))
-                    .ToList())
-                {
-                    metadata.Actors.Add(actor);
-                }
-
-                // directors
-                foreach (Director director in metadata.Directors
-                    .Filter(d => incomingMetadata.Directors.All(d2 => d2.Name != d.Name))
-                    .ToList())
-                {
-                    metadata.Directors.Remove(director);
-                }
-
-                foreach (Director director in incomingMetadata.Directors
-                    .Filter(d => metadata.Directors.All(d2 => d2.Name != d.Name))
-                    .ToList())
-                {
-                    metadata.Directors.Add(director);
-                }
-
-                // writers
-                foreach (Writer writer in metadata.Writers
-                    .Filter(w => incomingMetadata.Writers.All(w2 => w2.Name != w.Name))
-                    .ToList())
-                {
-                    metadata.Writers.Remove(writer);
-                }
-
-                foreach (Writer writer in incomingMetadata.Writers
-                    .Filter(w => metadata.Writers.All(w2 => w2.Name != w.Name))
-                    .ToList())
-                {
-                    metadata.Writers.Add(writer);
-                }
-
-                // guids
-                foreach (MetadataGuid guid in metadata.Guids
-                    .Filter(g => incomingMetadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Remove(guid);
-                }
-
-                foreach (MetadataGuid guid in incomingMetadata.Guids
-                    .Filter(g => metadata.Guids.All(g2 => g2.Guid != g.Guid))
-                    .ToList())
-                {
-                    metadata.Guids.Add(guid);
-                }
-
-                metadata.ReleaseDate = incomingMetadata.ReleaseDate;
-
-                // poster
-                Artwork incomingPoster =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                if (incomingPoster != null)
-                {
-                    Artwork poster = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Poster);
-                    if (poster == null)
-                    {
-                        poster = new Artwork { ArtworkKind = ArtworkKind.Poster };
-                        metadata.Artwork.Add(poster);
-                    }
-
-                    poster.Path = incomingPoster.Path;
-                    poster.DateAdded = incomingPoster.DateAdded;
-                    poster.DateUpdated = incomingPoster.DateUpdated;
-                }
-
-                // fan art
-                Artwork incomingFanArt =
-                    incomingMetadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                if (incomingFanArt != null)
-                {
-                    Artwork fanArt = metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.FanArt);
-                    if (fanArt == null)
-                    {
-                        fanArt = new Artwork { ArtworkKind = ArtworkKind.FanArt };
-                        metadata.Artwork.Add(fanArt);
-                    }
-
-                    fanArt.Path = incomingFanArt.Path;
-                    fanArt.DateAdded = incomingFanArt.DateAdded;
-                    fanArt.DateUpdated = incomingFanArt.DateUpdated;
-                }
-
-                // version
-                MediaVersion version = existing.MediaVersions.Head();
-                MediaVersion incomingVersion = movie.MediaVersions.Head();
-                version.Name = incomingVersion.Name;
-                version.DateAdded = incomingVersion.DateAdded;
-
-                // media file
-                MediaFile file = version.MediaFiles.Head();
-                MediaFile incomingFile = incomingVersion.MediaFiles.Head();
-                file.Path = incomingFile.Path;
-            }
-
-            await dbContext.SaveChangesAsync();
-
-            return maybeExisting;
-        }
-
-        public Task<bool> AddDirector(MovieMetadata metadata, Director director) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Director (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
-                new { director.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddWriter(MovieMetadata metadata, Writer writer) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Writer (Name, MovieMetadataId) VALUES (@Name, @MetadataId)",
-                new { writer.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<Unit> UpdatePath(int mediaFileId, string path) =>
-            _dbConnection.ExecuteAsync(
-                "UPDATE MediaFile SET Path = @Path WHERE Id = @MediaFileId",
-                new { Path = path, MediaFileId = mediaFileId }).Map(_ => Unit.Default);
-
-        private static async Task<Either<BaseError, MediaItemScanResult<Movie>>> AddMovie(
-            TvContext dbContext,
-            int libraryPathId,
-            string path)
-        {
-            try
-            {
-                var movie = new Movie
-                {
-                    LibraryPathId = libraryPathId,
-                    MediaVersions = new List<MediaVersion>
-                    {
-                        new()
-                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            },
-                            Streams = new List<MediaStream>()
-                        }
-                    },
-                    TraktListItems = new List<TraktListItem>()
-                };
-                await dbContext.Movies.AddAsync(movie);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(movie).Reference(m => m.LibraryPath).LoadAsync();
-                await dbContext.Entry(movie.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return new MediaItemScanResult<Movie>(movie) { IsAdded = true };
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> AddPlexMovie(
-            TvContext context,
-            PlexLibrary library,
-            PlexMovie item)
-        {
-            try
-            {
-                item.LibraryPathId = library.Paths.Head().Id;
-
-                await context.PlexMovies.AddAsync(item);
-                await context.SaveChangesAsync();
-                await context.Entry(item).Reference(i => i.LibraryPath).LoadAsync();
-                await context.Entry(item.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return new MediaItemScanResult<PlexMovie>(item) { IsAdded = true };
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
+            return BaseError.New(ex.Message);
         }
     }
-}
+
+    private async Task<Either<BaseError, MediaItemScanResult<PlexMovie>>> AddPlexMovie(
+        TvContext context,
+        PlexLibrary library,
+        PlexMovie item)
+    {
+        try
+        {
+            item.LibraryPathId = library.Paths.Head().Id;
+
+            await context.PlexMovies.AddAsync(item);
+            await context.SaveChangesAsync();
+            await context.Entry(item).Reference(i => i.LibraryPath).LoadAsync();
+            await context.Entry(item.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            return new MediaItemScanResult<PlexMovie>(item) { IsAdded = true };
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/MusicVideoRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/MusicVideoRepository.cs
index 2b62431bb..7450a44e8 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/MusicVideoRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/MusicVideoRepository.cs
@@ -1,222 +1,215 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class MusicVideoRepository : IMusicVideoRepository
 {
-    public class MusicVideoRepository : IMusicVideoRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public MusicVideoRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public MusicVideoRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> GetOrAdd(
+        Artist artist,
+        LibraryPath libraryPath,
+        string path)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<MusicVideo> maybeExisting = await dbContext.MusicVideos
+            .AsNoTracking()
+            .Include(mv => mv.Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .Include(mv => mv.MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Artwork)
+            .Include(mv => mv.MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Genres)
+            .Include(mv => mv.MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Tags)
+            .Include(mv => mv.MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Studios)
+            .Include(mv => mv.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(mv => mv.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(mv => mv.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(mv => mv.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(i => i.MediaVersions.First().MediaFiles.First().Path)
+            .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
 
-        public async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> GetOrAdd(
-            Artist artist,
-            LibraryPath libraryPath,
-            string path)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<MusicVideo> maybeExisting = await dbContext.MusicVideos
-                .AsNoTracking()
-                .Include(mv => mv.Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .Include(mv => mv.MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Artwork)
-                .Include(mv => mv.MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Genres)
-                .Include(mv => mv.MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Tags)
-                .Include(mv => mv.MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Studios)
-                .Include(mv => mv.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(mv => mv.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(mv => mv.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(mv => mv.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(i => i.MediaVersions.First().MediaFiles.First().Path)
-                .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
-
-            return await maybeExisting.Match(
-                async mediaItem =>
+        return await maybeExisting.Match(
+            async mediaItem =>
+            {
+                if (mediaItem.ArtistId != artist.Id)
                 {
-                    if (mediaItem.ArtistId != artist.Id)
-                    {
-                        await _dbConnection.ExecuteAsync(
-                            @"UPDATE MusicVideo SET ArtistId = @ArtistId WHERE Id = @Id",
-                            new { mediaItem.Id, ArtistId = artist.Id });
+                    await _dbConnection.ExecuteAsync(
+                        @"UPDATE MusicVideo SET ArtistId = @ArtistId WHERE Id = @Id",
+                        new { mediaItem.Id, ArtistId = artist.Id });
 
-                        mediaItem.ArtistId = artist.Id;
-                        mediaItem.Artist = artist;
-                    }
+                    mediaItem.ArtistId = artist.Id;
+                    mediaItem.Artist = artist;
+                }
 
-                    return Right<BaseError, MediaItemScanResult<MusicVideo>>(
-                        new MediaItemScanResult<MusicVideo>(mediaItem) { IsAdded = false });
-                },
-                async () => await AddMusicVideo(dbContext, artist, libraryPath.Id, path));
-        }
+                return Right<BaseError, MediaItemScanResult<MusicVideo>>(
+                    new MediaItemScanResult<MusicVideo>(mediaItem) { IsAdded = false });
+            },
+            async () => await AddMusicVideo(dbContext, artist, libraryPath.Id, path));
+    }
 
-        public Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT MF.Path
+    public Task<IEnumerable<string>> FindMusicVideoPaths(LibraryPath libraryPath) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT MF.Path
                 FROM MediaFile MF
                 INNER JOIN MediaVersion MV on MF.MediaVersionId = MV.Id
                 INNER JOIN MusicVideo M on MV.MusicVideoId = M.Id
                 INNER JOIN MediaItem MI on M.Id = MI.Id
                 WHERE MI.LibraryPathId = @LibraryPathId",
-                new { LibraryPathId = libraryPath.Id });
+            new { LibraryPathId = libraryPath.Id });
 
-        public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT M.Id
+    public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT M.Id
                 FROM MusicVideo M
                 INNER JOIN MediaItem MI on M.Id = MI.Id
                 INNER JOIN MediaVersion MV on M.Id = MV.MusicVideoId
                 INNER JOIN MediaFile MF on MV.Id = MF.MediaVersionId
                 WHERE MI.LibraryPathId = @LibraryPathId AND MF.Path = @Path",
-                new { LibraryPathId = libraryPath.Id, Path = path }).Map(result => result.ToList());
+            new { LibraryPathId = libraryPath.Id, Path = path }).Map(result => result.ToList());
 
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            foreach (int musicVideoId in ids)
-            {
-                MusicVideo musicVideo = await dbContext.MusicVideos.FindAsync(musicVideoId);
-                if (musicVideo != null)
-                {
-                    dbContext.MusicVideos.Remove(musicVideo);
-                }
-            }
-
-            await dbContext.SaveChangesAsync();
-
-            return ids;
-        }
-        
-        public Task<bool> AddGenre(MusicVideoMetadata metadata, Genre genre) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Genre (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
-                new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddTag(MusicVideoMetadata metadata, Tag tag) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Tag (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
-                new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddStudio(MusicVideoMetadata metadata, Studio studio) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Studio (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
-                new { studio.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public async Task<List<MusicVideoMetadata>> GetMusicVideosForCards(List<int> ids)
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        foreach (int musicVideoId in ids)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.MusicVideoMetadata
-                .AsNoTracking()
-                .Filter(mvm => ids.Contains(mvm.MusicVideoId))
-                .Include(mvm => mvm.MusicVideo)
-                .ThenInclude(mv => mv.Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .Include(mvm => mvm.MusicVideo)
-                .ThenInclude(e => e.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(mvm => mvm.Artwork)
-                .OrderBy(mvm => mvm.SortTitle)
-                .ToListAsync();
+            MusicVideo musicVideo = await dbContext.MusicVideos.FindAsync(musicVideoId);
+            if (musicVideo != null)
+            {
+                dbContext.MusicVideos.Remove(musicVideo);
+            }
         }
 
-        public Task<IEnumerable<string>> FindOrphanPaths(LibraryPath libraryPath) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT MF.Path
+        await dbContext.SaveChangesAsync();
+
+        return ids;
+    }
+        
+    public Task<bool> AddGenre(MusicVideoMetadata metadata, Genre genre) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Genre (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
+            new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddTag(MusicVideoMetadata metadata, Tag tag) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Tag (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
+            new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddStudio(MusicVideoMetadata metadata, Studio studio) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Studio (Name, MusicVideoMetadataId) VALUES (@Name, @MetadataId)",
+            new { studio.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public async Task<List<MusicVideoMetadata>> GetMusicVideosForCards(List<int> ids)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.MusicVideoMetadata
+            .AsNoTracking()
+            .Filter(mvm => ids.Contains(mvm.MusicVideoId))
+            .Include(mvm => mvm.MusicVideo)
+            .ThenInclude(mv => mv.Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .Include(mvm => mvm.MusicVideo)
+            .ThenInclude(e => e.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(mvm => mvm.Artwork)
+            .OrderBy(mvm => mvm.SortTitle)
+            .ToListAsync();
+    }
+
+    public Task<IEnumerable<string>> FindOrphanPaths(LibraryPath libraryPath) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT MF.Path
                 FROM MediaFile MF
                 INNER JOIN MediaVersion MV on MF.MediaVersionId = MV.Id
                 INNER JOIN MusicVideo M on MV.MusicVideoId = M.Id
                 INNER JOIN MediaItem MI on M.Id = MI.Id
                 WHERE MI.LibraryPathId = @LibraryPathId
                   AND NOT EXISTS (SELECT * FROM MusicVideoMetadata WHERE MusicVideoId = M.Id)",
-                new { LibraryPathId = libraryPath.Id });
+            new { LibraryPathId = libraryPath.Id });
 
-        public Task<int> GetMusicVideoCount(int artistId) =>
-            _dbConnection.QuerySingleAsync<int>(
-                @"SELECT COUNT(*) FROM MusicVideo WHERE ArtistId = @ArtistId",
-                new { ArtistId = artistId });
+    public Task<int> GetMusicVideoCount(int artistId) =>
+        _dbConnection.QuerySingleAsync<int>(
+            @"SELECT COUNT(*) FROM MusicVideo WHERE ArtistId = @ArtistId",
+            new { ArtistId = artistId });
 
-        public async Task<List<MusicVideoMetadata>> GetPagedMusicVideos(int artistId, int pageNumber, int pageSize)
+    public async Task<List<MusicVideoMetadata>> GetPagedMusicVideos(int artistId, int pageNumber, int pageSize)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.MusicVideoMetadata
+            .AsNoTracking()
+            .Include(m => m.Artwork)
+            .Include(m => m.Genres)
+            .Include(m => m.Tags)
+            .Include(m => m.Studios)
+            .Include(m => m.MusicVideo)
+            .ThenInclude(mv => mv.Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .Include(m => m.MusicVideo)
+            .ThenInclude(mv => mv.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Filter(m => m.MusicVideo.ArtistId == artistId)
+            .OrderBy(m => m.SortTitle)
+            .Skip((pageNumber - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync();
+    }
+
+    private static async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> AddMusicVideo(
+        TvContext dbContext,
+        Artist artist,
+        int libraryPathId,
+        string path)
+    {
+        try
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.MusicVideoMetadata
-                .AsNoTracking()
-                .Include(m => m.Artwork)
-                .Include(m => m.Genres)
-                .Include(m => m.Tags)
-                .Include(m => m.Studios)
-                .Include(m => m.MusicVideo)
-                .ThenInclude(mv => mv.Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .Include(m => m.MusicVideo)
-                .ThenInclude(mv => mv.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Filter(m => m.MusicVideo.ArtistId == artistId)
-                .OrderBy(m => m.SortTitle)
-                .Skip((pageNumber - 1) * pageSize)
-                .Take(pageSize)
-                .ToListAsync();
-        }
-
-        private static async Task<Either<BaseError, MediaItemScanResult<MusicVideo>>> AddMusicVideo(
-            TvContext dbContext,
-            Artist artist,
-            int libraryPathId,
-            string path)
-        {
-            try
+            var musicVideo = new MusicVideo
             {
-                var musicVideo = new MusicVideo
+                ArtistId = artist.Id,
+                LibraryPathId = libraryPathId,
+                MediaVersions = new List<MediaVersion>
                 {
-                    ArtistId = artist.Id,
-                    LibraryPathId = libraryPathId,
-                    MediaVersions = new List<MediaVersion>
+                    new()
                     {
-                        new()
+                        MediaFiles = new List<MediaFile>
                         {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            },
-                            Streams = new List<MediaStream>()
-                        }
-                    },
-                    TraktListItems = new List<TraktListItem>()
-                };
+                            new() { Path = path }
+                        },
+                        Streams = new List<MediaStream>()
+                    }
+                },
+                TraktListItems = new List<TraktListItem>()
+            };
 
-                await dbContext.MusicVideos.AddAsync(musicVideo);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(musicVideo).Reference(m => m.Artist).LoadAsync();
-                await dbContext.Entry(musicVideo.Artist).Collection(a => a.ArtistMetadata).LoadAsync();
-                await dbContext.Entry(musicVideo).Reference(m => m.LibraryPath).LoadAsync();
-                await dbContext.Entry(musicVideo.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return new MediaItemScanResult<MusicVideo>(musicVideo) { IsAdded = true };
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
+            await dbContext.MusicVideos.AddAsync(musicVideo);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(musicVideo).Reference(m => m.Artist).LoadAsync();
+            await dbContext.Entry(musicVideo.Artist).Collection(a => a.ArtistMetadata).LoadAsync();
+            await dbContext.Entry(musicVideo).Reference(m => m.LibraryPath).LoadAsync();
+            await dbContext.Entry(musicVideo.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            return new MediaItemScanResult<MusicVideo>(musicVideo) { IsAdded = true };
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/OtherVideoRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/OtherVideoRepository.cs
index 47df07b06..d6f3a659f 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/OtherVideoRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/OtherVideoRepository.cs
@@ -1,146 +1,139 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class OtherVideoRepository : IOtherVideoRepository
 {
-    public class OtherVideoRepository : IOtherVideoRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public OtherVideoRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbConnection = dbConnection;
+        _dbContextFactory = dbContextFactory;
+    }
 
-        public OtherVideoRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _dbConnection = dbConnection;
-            _dbContextFactory = dbContextFactory;
-        }
+    public async Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> GetOrAdd(
+        LibraryPath libraryPath,
+        string path)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        Option<OtherVideo> maybeExisting = await dbContext.OtherVideos
+            .AsNoTracking()
+            .Include(ov => ov.OtherVideoMetadata)
+            .ThenInclude(ovm => ovm.Artwork)
+            .Include(ov => ov.OtherVideoMetadata)
+            .ThenInclude(ovm => ovm.Tags)
+            .Include(ov => ov.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(ov => ov.MediaVersions)
+            .ThenInclude(ov => ov.MediaFiles)
+            .Include(ov => ov.MediaVersions)
+            .ThenInclude(ov => ov.Streams)
+            .Include(ov => ov.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(i => i.MediaVersions.First().MediaFiles.First().Path)
+            .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
 
-        public async Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> GetOrAdd(
-            LibraryPath libraryPath,
-            string path)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            Option<OtherVideo> maybeExisting = await dbContext.OtherVideos
-                .AsNoTracking()
-                .Include(ov => ov.OtherVideoMetadata)
-                .ThenInclude(ovm => ovm.Artwork)
-                .Include(ov => ov.OtherVideoMetadata)
-                .ThenInclude(ovm => ovm.Tags)
-                .Include(ov => ov.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(ov => ov.MediaVersions)
-                .ThenInclude(ov => ov.MediaFiles)
-                .Include(ov => ov.MediaVersions)
-                .ThenInclude(ov => ov.Streams)
-                .Include(ov => ov.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(i => i.MediaVersions.First().MediaFiles.First().Path)
-                .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
+        return await maybeExisting.Match(
+            mediaItem =>
+                Right<BaseError, MediaItemScanResult<OtherVideo>>(
+                    new MediaItemScanResult<OtherVideo>(mediaItem) { IsAdded = false }).AsTask(),
+            async () => await AddOtherVideo(dbContext, libraryPath.Id, path));
+    }
 
-            return await maybeExisting.Match(
-                mediaItem =>
-                    Right<BaseError, MediaItemScanResult<OtherVideo>>(
-                        new MediaItemScanResult<OtherVideo>(mediaItem) { IsAdded = false }).AsTask(),
-                async () => await AddOtherVideo(dbContext, libraryPath.Id, path));
-        }
-
-        public Task<IEnumerable<string>> FindOtherVideoPaths(LibraryPath libraryPath) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT MF.Path
+    public Task<IEnumerable<string>> FindOtherVideoPaths(LibraryPath libraryPath) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT MF.Path
                 FROM MediaFile MF
                 INNER JOIN MediaVersion MV on MF.MediaVersionId = MV.Id
                 INNER JOIN OtherVideo O on MV.OtherVideoId = O.Id
                 INNER JOIN MediaItem MI on O.Id = MI.Id
                 WHERE MI.LibraryPathId = @LibraryPathId",
-                new { LibraryPathId = libraryPath.Id });
+            new { LibraryPathId = libraryPath.Id });
 
-        public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT O.Id
+    public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT O.Id
             FROM OtherVideo O
             INNER JOIN MediaItem MI on O.Id = MI.Id
             INNER JOIN MediaVersion MV on O.Id = MV.OtherVideoId
             INNER JOIN MediaFile MF on MV.Id = MF.MediaVersionId
             WHERE MI.LibraryPathId = @LibraryPathId AND MF.Path = @Path",
-                new { LibraryPathId = libraryPath.Id, Path = path }).Map(result => result.ToList());
+            new { LibraryPathId = libraryPath.Id, Path = path }).Map(result => result.ToList());
 
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            foreach (int otherVideoId in ids)
-            {
-                OtherVideo otherVideo = await dbContext.OtherVideos.FindAsync(otherVideoId);
-                dbContext.OtherVideos.Remove(otherVideo);
-            }
-
-            await dbContext.SaveChangesAsync();
-
-            return ids;
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        foreach (int otherVideoId in ids)
+        {
+            OtherVideo otherVideo = await dbContext.OtherVideos.FindAsync(otherVideoId);
+            dbContext.OtherVideos.Remove(otherVideo);
         }
 
-        public Task<bool> AddTag(OtherVideoMetadata metadata, Tag tag) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Tag (Name, OtherVideoMetadataId) VALUES (@Name, @MetadataId)",
-                new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+        await dbContext.SaveChangesAsync();
 
-        public async Task<List<OtherVideoMetadata>> GetOtherVideosForCards(List<int> ids)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            return await dbContext.OtherVideoMetadata
-                .AsNoTracking()
-                .Filter(ovm => ids.Contains(ovm.OtherVideoId))
-                .Include(ovm => ovm.OtherVideo)
-                .Include(ovm => ovm.Artwork)
-                .Include(ovm => ovm.OtherVideo)
-                .ThenInclude(ov => ov.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .OrderBy(ovm => ovm.SortTitle)
-                .ToListAsync();
-        }
+        return ids;
+    }
 
-        private static async Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> AddOtherVideo(
-            TvContext dbContext,
-            int libraryPathId,
-            string path)
+    public Task<bool> AddTag(OtherVideoMetadata metadata, Tag tag) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Tag (Name, OtherVideoMetadataId) VALUES (@Name, @MetadataId)",
+            new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public async Task<List<OtherVideoMetadata>> GetOtherVideosForCards(List<int> ids)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        return await dbContext.OtherVideoMetadata
+            .AsNoTracking()
+            .Filter(ovm => ids.Contains(ovm.OtherVideoId))
+            .Include(ovm => ovm.OtherVideo)
+            .Include(ovm => ovm.Artwork)
+            .Include(ovm => ovm.OtherVideo)
+            .ThenInclude(ov => ov.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .OrderBy(ovm => ovm.SortTitle)
+            .ToListAsync();
+    }
+
+    private static async Task<Either<BaseError, MediaItemScanResult<OtherVideo>>> AddOtherVideo(
+        TvContext dbContext,
+        int libraryPathId,
+        string path)
+    {
+        try
         {
-            try
+            var otherVideo = new OtherVideo
             {
-                var otherVideo = new OtherVideo
+                LibraryPathId = libraryPathId,
+                MediaVersions = new List<MediaVersion>
                 {
-                    LibraryPathId = libraryPathId,
-                    MediaVersions = new List<MediaVersion>
+                    new()
                     {
-                        new()
+                        MediaFiles = new List<MediaFile>
                         {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            },
-                            Streams = new List<MediaStream>()
-                        }
-                    },
-                    TraktListItems = new List<TraktListItem>()
-                };
+                            new() { Path = path }
+                        },
+                        Streams = new List<MediaStream>()
+                    }
+                },
+                TraktListItems = new List<TraktListItem>()
+            };
 
-                await dbContext.OtherVideos.AddAsync(otherVideo);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(otherVideo).Reference(m => m.LibraryPath).LoadAsync();
-                await dbContext.Entry(otherVideo.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return new MediaItemScanResult<OtherVideo>(otherVideo) { IsAdded = true };
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
+            await dbContext.OtherVideos.AddAsync(otherVideo);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(otherVideo).Reference(m => m.LibraryPath).LoadAsync();
+            await dbContext.Entry(otherVideo.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            return new MediaItemScanResult<OtherVideo>(otherVideo) { IsAdded = true };
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/SearchRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/SearchRepository.cs
index 5334af33c..e754ac805 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/SearchRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/SearchRepository.cs
@@ -1,154 +1,148 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Extensions;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class SearchRepository : ISearchRepository
 {
-    public class SearchRepository : ISearchRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public SearchRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbContextFactory = dbContextFactory;
+        _dbConnection = dbConnection;
+    }
 
-        public SearchRepository(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
-        {
-            _dbContextFactory = dbContextFactory;
-            _dbConnection = dbConnection;
-        }
+    public Task<List<int>> GetItemIdsToIndex() =>
+        _dbConnection.QueryAsync<int>(@"SELECT Id FROM MediaItem")
+            .Map(result => result.ToList());
 
-        public Task<List<int>> GetItemIdsToIndex() =>
-            _dbConnection.QueryAsync<int>(@"SELECT Id FROM MediaItem")
-                .Map(result => result.ToList());
+    public async Task<Option<MediaItem>> GetItemToIndex(int id)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.MediaItems
+            .AsNoTracking()
+            .Include(mi => mi.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(mi => (mi as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(mi => (mi as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(mi => (mi as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(mi => (mi as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(mi => (mi as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(mi => (mi as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(mi => (mi as Movie).MediaVersions)
+            .ThenInclude(mm => mm.Streams)
+            .Include(mi => (mi as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Genres)
+            .Include(mi => (mi as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Tags)
+            .Include(mi => (mi as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Studios)
+            .Include(mi => (mi as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Actors)
+            .Include(mi => (mi as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Directors)
+            .Include(mi => (mi as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Writers)
+            .Include(mi => (mi as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Guids)
+            .Include(mi => (mi as Episode).MediaVersions)
+            .ThenInclude(em => em.Streams)
+            .Include(mi => (mi as Episode).Season)
+            .Include(mi => (mi as Season).SeasonMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(mi => (mi as Season).SeasonMetadata)
+            .ThenInclude(sm => sm.Tags)
+            .Include(mi => (mi as Season).SeasonMetadata)
+            .ThenInclude(sm => sm.Studios)
+            .Include(mi => (mi as Season).SeasonMetadata)
+            .ThenInclude(sm => sm.Actors)
+            .Include(mi => (mi as Season).Show)
+            .ThenInclude(sm => sm.ShowMetadata)
+            .Include(mi => (mi as Show).ShowMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(mi => (mi as Show).ShowMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(mi => (mi as Show).ShowMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(mi => (mi as Show).ShowMetadata)
+            .ThenInclude(mm => mm.Actors)
+            .Include(mi => (mi as MusicVideo).Artist)
+            .ThenInclude(mm => mm.ArtistMetadata)
+            .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(mi => (mi as MusicVideo).MediaVersions)
+            .ThenInclude(mm => mm.Streams)
+            .Include(mi => (mi as Artist).ArtistMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(mi => (mi as Artist).ArtistMetadata)
+            .ThenInclude(mm => mm.Styles)
+            .Include(mi => (mi as Artist).ArtistMetadata)
+            .ThenInclude(mm => mm.Moods)
+            .Include(mi => (mi as OtherVideo).OtherVideoMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(mi => (mi as OtherVideo).MediaVersions)
+            .ThenInclude(mm => mm.Streams)
+            .Include(mi => (mi as Song).SongMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(mi => (mi as Song).SongMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(mi => (mi as Song).MediaVersions)
+            .ThenInclude(mm => mm.Streams)
+            .Include(mi => mi.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(mi => mi.Id)
+            .SingleOrDefaultAsync(mi => mi.Id == id)
+            .Map(Optional);
+    }
 
-        public async Task<Option<MediaItem>> GetItemToIndex(int id)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.MediaItems
-                .AsNoTracking()
-                .Include(mi => mi.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(mi => (mi as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(mi => (mi as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(mi => (mi as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(mi => (mi as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(mi => (mi as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(mi => (mi as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(mi => (mi as Movie).MediaVersions)
-                .ThenInclude(mm => mm.Streams)
-                .Include(mi => (mi as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Genres)
-                .Include(mi => (mi as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Tags)
-                .Include(mi => (mi as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Studios)
-                .Include(mi => (mi as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Actors)
-                .Include(mi => (mi as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Directors)
-                .Include(mi => (mi as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Writers)
-                .Include(mi => (mi as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Guids)
-                .Include(mi => (mi as Episode).MediaVersions)
-                .ThenInclude(em => em.Streams)
-                .Include(mi => (mi as Episode).Season)
-                .Include(mi => (mi as Season).SeasonMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(mi => (mi as Season).SeasonMetadata)
-                .ThenInclude(sm => sm.Tags)
-                .Include(mi => (mi as Season).SeasonMetadata)
-                .ThenInclude(sm => sm.Studios)
-                .Include(mi => (mi as Season).SeasonMetadata)
-                .ThenInclude(sm => sm.Actors)
-                .Include(mi => (mi as Season).Show)
-                .ThenInclude(sm => sm.ShowMetadata)
-                .Include(mi => (mi as Show).ShowMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(mi => (mi as Show).ShowMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(mi => (mi as Show).ShowMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(mi => (mi as Show).ShowMetadata)
-                .ThenInclude(mm => mm.Actors)
-                .Include(mi => (mi as MusicVideo).Artist)
-                .ThenInclude(mm => mm.ArtistMetadata)
-                .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(mi => (mi as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(mi => (mi as MusicVideo).MediaVersions)
-                .ThenInclude(mm => mm.Streams)
-                .Include(mi => (mi as Artist).ArtistMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(mi => (mi as Artist).ArtistMetadata)
-                .ThenInclude(mm => mm.Styles)
-                .Include(mi => (mi as Artist).ArtistMetadata)
-                .ThenInclude(mm => mm.Moods)
-                .Include(mi => (mi as OtherVideo).OtherVideoMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(mi => (mi as OtherVideo).MediaVersions)
-                .ThenInclude(mm => mm.Streams)
-                .Include(mi => (mi as Song).SongMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(mi => (mi as Song).SongMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(mi => (mi as Song).MediaVersions)
-                .ThenInclude(mm => mm.Streams)
-                .Include(mi => mi.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(mi => mi.Id)
-                .SingleOrDefaultAsync(mi => mi.Id == id)
-                .Map(Optional);
-        }
-
-        public Task<List<string>> GetLanguagesForShow(Show show) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT DISTINCT Language
+    public Task<List<string>> GetLanguagesForShow(Show show) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT DISTINCT Language
                     FROM MediaStream
                     INNER JOIN MediaVersion MV ON MediaStream.MediaVersionId = MV.Id
                     INNER JOIN Episode E ON MV.EpisodeId = E.Id
                     INNER JOIN Season S ON E.SeasonId = S.Id
                     WHERE MediaStreamKind = 2 AND S.ShowId = @ShowId",
-                new { ShowId = show.Id }).Map(result => result.ToList());
+            new { ShowId = show.Id }).Map(result => result.ToList());
 
-        public Task<List<string>> GetLanguagesForSeason(Season season) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT DISTINCT Language
+    public Task<List<string>> GetLanguagesForSeason(Season season) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT DISTINCT Language
                     FROM MediaStream
                     INNER JOIN MediaVersion MV ON MediaStream.MediaVersionId = MV.Id
                     INNER JOIN Episode E ON MV.EpisodeId = E.Id
                     WHERE MediaStreamKind = 2 AND E.SeasonId = @SeasonId",
-                new { SeasonId = season.Id }).Map(result => result.ToList());
+            new { SeasonId = season.Id }).Map(result => result.ToList());
 
-        public Task<List<string>> GetLanguagesForArtist(Artist artist) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT DISTINCT Language
+    public Task<List<string>> GetLanguagesForArtist(Artist artist) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT DISTINCT Language
                     FROM MediaStream
                     INNER JOIN MediaVersion V ON MediaStream.MediaVersionId = V.Id
                     INNER JOIN MusicVideo MV ON V.MusicVideoId = MV.Id
                     INNER JOIN Artist A on MV.ArtistId = A.Id
                     WHERE MediaStreamKind = 2 AND A.Id = @ArtistId",
-                new { ArtistId = artist.Id }).Map(result => result.ToList());
+            new { ArtistId = artist.Id }).Map(result => result.ToList());
         
-        public async Task<List<string>> GetAllLanguageCodes(List<string> mediaCodes)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.LanguageCodes.GetAllLanguageCodes(mediaCodes);
-        }
+    public async Task<List<string>> GetAllLanguageCodes(List<string> mediaCodes)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.LanguageCodes.GetAllLanguageCodes(mediaCodes);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/SongRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/SongRepository.cs
index 52b512c50..ca6259ed3 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/SongRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/SongRepository.cs
@@ -1,159 +1,152 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class SongRepository : ISongRepository
 {
-    public class SongRepository : ISongRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public SongRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbConnection = dbConnection;
+        _dbContextFactory = dbContextFactory;
+    }
 
-        public SongRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _dbConnection = dbConnection;
-            _dbContextFactory = dbContextFactory;
-        }
+    public async Task<Either<BaseError, MediaItemScanResult<Song>>> GetOrAdd(
+        LibraryPath libraryPath,
+        string path)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<Song> maybeExisting = await dbContext.Songs
+            .AsNoTracking()
+            .Include(s => s.SongMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(s => s.SongMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(s => s.SongMetadata)
+            .ThenInclude(sm => sm.Studios)
+            .Include(s => s.SongMetadata)
+            .ThenInclude(sm => sm.Tags)
+            .Include(s => s.SongMetadata)
+            .Include(s => s.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(s => s.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(s => s.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(s => s.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(s => s.MediaVersions.First().MediaFiles.First().Path)
+            .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
 
-        public async Task<Either<BaseError, MediaItemScanResult<Song>>> GetOrAdd(
-            LibraryPath libraryPath,
-            string path)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<Song> maybeExisting = await dbContext.Songs
-                .AsNoTracking()
-                .Include(s => s.SongMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(s => s.SongMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(s => s.SongMetadata)
-                .ThenInclude(sm => sm.Studios)
-                .Include(s => s.SongMetadata)
-                .ThenInclude(sm => sm.Tags)
-                .Include(s => s.SongMetadata)
-                .Include(s => s.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(s => s.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(s => s.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(s => s.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(s => s.MediaVersions.First().MediaFiles.First().Path)
-                .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
+        return await maybeExisting.Match(
+            mediaItem =>
+                Right<BaseError, MediaItemScanResult<Song>>(
+                    new MediaItemScanResult<Song>(mediaItem) { IsAdded = false }).AsTask(),
+            async () => await AddSong(dbContext, libraryPath.Id, path));
+    }
 
-            return await maybeExisting.Match(
-                mediaItem =>
-                    Right<BaseError, MediaItemScanResult<Song>>(
-                        new MediaItemScanResult<Song>(mediaItem) { IsAdded = false }).AsTask(),
-                async () => await AddSong(dbContext, libraryPath.Id, path));
-        }
-
-        public Task<IEnumerable<string>> FindSongPaths(LibraryPath libraryPath) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT MF.Path
+    public Task<IEnumerable<string>> FindSongPaths(LibraryPath libraryPath) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT MF.Path
                 FROM MediaFile MF
                 INNER JOIN MediaVersion MV on MF.MediaVersionId = MV.Id
                 INNER JOIN Song O on MV.SongId = O.Id
                 INNER JOIN MediaItem MI on O.Id = MI.Id
                 WHERE MI.LibraryPathId = @LibraryPathId",
-                new { LibraryPathId = libraryPath.Id });
+            new { LibraryPathId = libraryPath.Id });
 
-        public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT O.Id
+    public async Task<List<int>> DeleteByPath(LibraryPath libraryPath, string path)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT O.Id
             FROM Song O
             INNER JOIN MediaItem MI on O.Id = MI.Id
             INNER JOIN MediaVersion MV on O.Id = MV.SongId
             INNER JOIN MediaFile MF on MV.Id = MF.MediaVersionId
             WHERE MI.LibraryPathId = @LibraryPathId AND MF.Path = @Path",
-                new { LibraryPathId = libraryPath.Id, Path = path }).Map(result => result.ToList());
+            new { LibraryPathId = libraryPath.Id, Path = path }).Map(result => result.ToList());
 
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            foreach (int songId in ids)
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        foreach (int songId in ids)
+        {
+            Song song = await dbContext.Songs.FindAsync(songId);
+            if (song != null)
             {
-                Song song = await dbContext.Songs.FindAsync(songId);
-                if (song != null)
-                {
-                    dbContext.Songs.Remove(song);
-                }
+                dbContext.Songs.Remove(song);
             }
-
-            await dbContext.SaveChangesAsync();
-
-            return ids;
         }
 
-        public Task<bool> AddGenre(SongMetadata metadata, Genre genre) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Genre (Name, SongMetadataId) VALUES (@Name, @MetadataId)",
-                new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+        await dbContext.SaveChangesAsync();
 
-        public Task<bool> AddTag(SongMetadata metadata, Tag tag) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Tag (Name, SongMetadataId) VALUES (@Name, @MetadataId)",
-                new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+        return ids;
+    }
 
-        public async Task<List<SongMetadata>> GetSongsForCards(List<int> ids)
+    public Task<bool> AddGenre(SongMetadata metadata, Genre genre) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Genre (Name, SongMetadataId) VALUES (@Name, @MetadataId)",
+            new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddTag(SongMetadata metadata, Tag tag) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Tag (Name, SongMetadataId) VALUES (@Name, @MetadataId)",
+            new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public async Task<List<SongMetadata>> GetSongsForCards(List<int> ids)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.SongMetadata
+            .AsNoTracking()
+            .Filter(ovm => ids.Contains(ovm.SongId))
+            .Include(ovm => ovm.Song)
+            .Include(ovm => ovm.Artwork)
+            .Include(sm => sm.Song)
+            .ThenInclude(s => s.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .OrderBy(ovm => ovm.SortTitle)
+            .ToListAsync();
+    }
+
+    private static async Task<Either<BaseError, MediaItemScanResult<Song>>> AddSong(
+        TvContext dbContext,
+        int libraryPathId,
+        string path)
+    {
+        try
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.SongMetadata
-                .AsNoTracking()
-                .Filter(ovm => ids.Contains(ovm.SongId))
-                .Include(ovm => ovm.Song)
-                .Include(ovm => ovm.Artwork)
-                .Include(sm => sm.Song)
-                .ThenInclude(s => s.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .OrderBy(ovm => ovm.SortTitle)
-                .ToListAsync();
-        }
-
-        private static async Task<Either<BaseError, MediaItemScanResult<Song>>> AddSong(
-            TvContext dbContext,
-            int libraryPathId,
-            string path)
-        {
-            try
+            var song = new Song
             {
-                var song = new Song
+                LibraryPathId = libraryPathId,
+                MediaVersions = new List<MediaVersion>
                 {
-                    LibraryPathId = libraryPathId,
-                    MediaVersions = new List<MediaVersion>
+                    new()
                     {
-                        new()
+                        MediaFiles = new List<MediaFile>
                         {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            },
-                            Streams = new List<MediaStream>()
-                        }
-                    },
-                    TraktListItems = new List<TraktListItem>()
-                };
+                            new() { Path = path }
+                        },
+                        Streams = new List<MediaStream>()
+                    }
+                },
+                TraktListItems = new List<TraktListItem>()
+            };
 
-                await dbContext.Songs.AddAsync(song);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(song).Reference(m => m.LibraryPath).LoadAsync();
-                await dbContext.Entry(song.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return new MediaItemScanResult<Song>(song) { IsAdded = true };
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
+            await dbContext.Songs.AddAsync(song);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(song).Reference(m => m.LibraryPath).LoadAsync();
+            await dbContext.Entry(song.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            return new MediaItemScanResult<Song>(song) { IsAdded = true };
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/TelevisionRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/TelevisionRepository.cs
index 677c97499..a81cc6438 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/TelevisionRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/TelevisionRepository.cs
@@ -1,878 +1,871 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Data;
 using Dapper;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Metadata;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Data.Repositories
+namespace ErsatzTV.Infrastructure.Data.Repositories;
+
+public class TelevisionRepository : ITelevisionRepository
 {
-    public class TelevisionRepository : ITelevisionRepository
+    private readonly IDbConnection _dbConnection;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public TelevisionRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbConnection _dbConnection;
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        _dbConnection = dbConnection;
+        _dbContextFactory = dbContextFactory;
+    }
 
-        public TelevisionRepository(IDbConnection dbConnection, IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _dbConnection = dbConnection;
-            _dbContextFactory = dbContextFactory;
-        }
+    public Task<bool> AllShowsExist(List<int> showIds) =>
+        _dbConnection.QuerySingleAsync<int>(
+                "SELECT COUNT(*) FROM Show WHERE Id in @ShowIds",
+                new { ShowIds = showIds })
+            .Map(c => c == showIds.Count);
 
-        public Task<bool> AllShowsExist(List<int> showIds) =>
-            _dbConnection.QuerySingleAsync<int>(
-                    "SELECT COUNT(*) FROM Show WHERE Id in @ShowIds",
-                    new { ShowIds = showIds })
-                .Map(c => c == showIds.Count);
+    public Task<bool> AllSeasonsExist(List<int> seasonIds) =>
+        _dbConnection.QuerySingleAsync<int>(
+                "SELECT COUNT(*) FROM Season WHERE Id in @SeasonIds",
+                new { SeasonIds = seasonIds })
+            .Map(c => c == seasonIds.Count);
 
-        public Task<bool> AllSeasonsExist(List<int> seasonIds) =>
-            _dbConnection.QuerySingleAsync<int>(
-                    "SELECT COUNT(*) FROM Season WHERE Id in @SeasonIds",
-                    new { SeasonIds = seasonIds })
-                .Map(c => c == seasonIds.Count);
+    public Task<bool> AllEpisodesExist(List<int> episodeIds) =>
+        _dbConnection.QuerySingleAsync<int>(
+                "SELECT COUNT(*) FROM Episode WHERE Id in @EpisodeIds",
+                new { EpisodeIds = episodeIds })
+            .Map(c => c == episodeIds.Count);
 
-        public Task<bool> AllEpisodesExist(List<int> episodeIds) =>
-            _dbConnection.QuerySingleAsync<int>(
-                    "SELECT COUNT(*) FROM Episode WHERE Id in @EpisodeIds",
-                    new { EpisodeIds = episodeIds })
-                .Map(c => c == episodeIds.Count);
+    public async Task<List<Show>> GetAllShows()
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Shows
+            .AsNoTracking()
+            .Include(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .ToListAsync();
+    }
 
-        public async Task<List<Show>> GetAllShows()
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Shows
-                .AsNoTracking()
-                .Include(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .ToListAsync();
-        }
+    public async Task<Option<Show>> GetShow(int showId)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Shows
+            .AsNoTracking()
+            .Filter(s => s.Id == showId)
+            .Include(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Tags)
+            .Include(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Studios)
+            .Include(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Actors)
+            .ThenInclude(a => a.Artwork)
+            .OrderBy(s => s.Id)
+            .SingleOrDefaultAsync()
+            .Map(Optional);
+    }
 
-        public async Task<Option<Show>> GetShow(int showId)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Shows
-                .AsNoTracking()
-                .Filter(s => s.Id == showId)
-                .Include(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Tags)
-                .Include(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Studios)
-                .Include(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Actors)
-                .ThenInclude(a => a.Artwork)
-                .OrderBy(s => s.Id)
-                .SingleOrDefaultAsync()
-                .Map(Optional);
-        }
+    public async Task<List<ShowMetadata>> GetShowsForCards(List<int> ids)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.ShowMetadata
+            .AsNoTracking()
+            .Filter(sm => ids.Contains(sm.ShowId))
+            .Include(sm => sm.Artwork)
+            .Include(sm => sm.Show)
+            .OrderBy(sm => sm.SortTitle)
+            .ToListAsync();
+    }
 
-        public async Task<List<ShowMetadata>> GetShowsForCards(List<int> ids)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.ShowMetadata
-                .AsNoTracking()
-                .Filter(sm => ids.Contains(sm.ShowId))
-                .Include(sm => sm.Artwork)
-                .Include(sm => sm.Show)
-                .OrderBy(sm => sm.SortTitle)
-                .ToListAsync();
-        }
+    public async Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.SeasonMetadata
+            .AsNoTracking()
+            .Filter(s => ids.Contains(s.SeasonId))
+            .Include(s => s.Season.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Include(sm => sm.Artwork)
+            .ToListAsync()
+            .Map(
+                list => list
+                    .OrderBy(s => s.Season.Show.ShowMetadata.HeadOrNone().Match(sm => sm.SortTitle, () => string.Empty))
+                    .ThenBy(s => s.Season.SeasonNumber)
+                    .ToList());
+    }
 
-        public async Task<List<SeasonMetadata>> GetSeasonsForCards(List<int> ids)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.SeasonMetadata
-                .AsNoTracking()
-                .Filter(s => ids.Contains(s.SeasonId))
-                .Include(s => s.Season.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Include(sm => sm.Artwork)
-                .ToListAsync()
-                .Map(
-                    list => list
-                        .OrderBy(s => s.Season.Show.ShowMetadata.HeadOrNone().Match(sm => sm.SortTitle, () => string.Empty))
-                        .ThenBy(s => s.Season.SeasonNumber)
-                        .ToList());
-        }
+    public async Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.EpisodeMetadata
+            .AsNoTracking()
+            .Filter(em => ids.Contains(em.EpisodeId))
+            .Include(em => em.Artwork)
+            .Include(em => em.Directors)
+            .Include(em => em.Writers)
+            .Include(em => em.Episode)
+            .ThenInclude(e => e.Season)
+            .ThenInclude(s => s.SeasonMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(em => em.Episode)
+            .ThenInclude(e => e.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(em => em.Episode)
+            .ThenInclude(e => e.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .OrderBy(em => em.SortTitle)
+            .ToListAsync();
+    }
 
-        public async Task<List<EpisodeMetadata>> GetEpisodesForCards(List<int> ids)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.EpisodeMetadata
-                .AsNoTracking()
-                .Filter(em => ids.Contains(em.EpisodeId))
-                .Include(em => em.Artwork)
-                .Include(em => em.Directors)
-                .Include(em => em.Writers)
-                .Include(em => em.Episode)
-                .ThenInclude(e => e.Season)
-                .ThenInclude(s => s.SeasonMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(em => em.Episode)
-                .ThenInclude(e => e.Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(em => em.Episode)
-                .ThenInclude(e => e.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .OrderBy(em => em.SortTitle)
-                .ToListAsync();
-        }
+    public async Task<List<Season>> GetAllSeasons()
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Seasons
+            .AsNoTracking()
+            .Include(s => s.SeasonMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .ToListAsync();
+    }
 
-        public async Task<List<Season>> GetAllSeasons()
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Seasons
-                .AsNoTracking()
-                .Include(s => s.SeasonMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .ToListAsync();
-        }
+    public async Task<Option<Season>> GetSeason(int seasonId)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Seasons
+            .AsNoTracking()
+            .Include(s => s.SeasonMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .OrderBy(s => s.Id)
+            .SingleOrDefaultAsync(s => s.Id == seasonId)
+            .Map(Optional);
+    }
 
-        public async Task<Option<Season>> GetSeason(int seasonId)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Seasons
-                .AsNoTracking()
-                .Include(s => s.SeasonMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .OrderBy(s => s.Id)
-                .SingleOrDefaultAsync(s => s.Id == seasonId)
-                .Map(Optional);
-        }
+    public async Task<int> GetSeasonCount(int showId)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Seasons
+            .AsNoTracking()
+            .CountAsync(s => s.ShowId == showId);
+    }
 
-        public async Task<int> GetSeasonCount(int showId)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Seasons
-                .AsNoTracking()
-                .CountAsync(s => s.ShowId == showId);
-        }
-
-        public async Task<List<Season>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize)
-        {
-            List<int> showIds = await _dbConnection.QueryAsync<int>(
-                    @"SELECT m1.ShowId
+    public async Task<List<Season>> GetPagedSeasons(int televisionShowId, int pageNumber, int pageSize)
+    {
+        List<int> showIds = await _dbConnection.QueryAsync<int>(
+                @"SELECT m1.ShowId
                 FROM ShowMetadata m1
                 LEFT OUTER JOIN ShowMetadata m2 ON m2.ShowId = @ShowId
                 WHERE m1.Title = m2.Title AND m1.Year is m2.Year",
-                    new { ShowId = televisionShowId })
-                .Map(results => results.ToList());
+                new { ShowId = televisionShowId })
+            .Map(results => results.ToList());
 
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Seasons
-                .AsNoTracking()
-                .Where(s => showIds.Contains(s.ShowId))
-                .Include(s => s.SeasonMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .OrderBy(s => s.SeasonNumber)
-                .Skip((pageNumber - 1) * pageSize)
-                .Take(pageSize)
-                .ToListAsync();
-        }
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Seasons
+            .AsNoTracking()
+            .Where(s => showIds.Contains(s.ShowId))
+            .Include(s => s.SeasonMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .OrderBy(s => s.SeasonNumber)
+            .Skip((pageNumber - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync();
+    }
 
-        public async Task<int> GetEpisodeCount(int seasonId)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Episodes
-                .AsNoTracking()
-                .CountAsync(e => e.SeasonId == seasonId);
-        }
+    public async Task<int> GetEpisodeCount(int seasonId)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Episodes
+            .AsNoTracking()
+            .CountAsync(e => e.SeasonId == seasonId);
+    }
 
-        public async Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.EpisodeMetadata
-                .AsNoTracking()
-                .Filter(em => em.Episode.SeasonId == seasonId)
-                .Include(em => em.Artwork)
-                .Include(em => em.Directors)
-                .Include(em => em.Writers)
-                .Include(em => em.Episode)
-                .ThenInclude(e => e.Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Actors)
-                .ThenInclude(a => a.Artwork)
-                .Include(em => em.Episode)
-                .ThenInclude(e => e.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .OrderBy(em => em.EpisodeNumber)
-                .Skip((pageNumber - 1) * pageSize)
-                .Take(pageSize)
-                .ToListAsync();
-        }
+    public async Task<List<EpisodeMetadata>> GetPagedEpisodes(int seasonId, int pageNumber, int pageSize)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.EpisodeMetadata
+            .AsNoTracking()
+            .Filter(em => em.Episode.SeasonId == seasonId)
+            .Include(em => em.Artwork)
+            .Include(em => em.Directors)
+            .Include(em => em.Writers)
+            .Include(em => em.Episode)
+            .ThenInclude(e => e.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Actors)
+            .ThenInclude(a => a.Artwork)
+            .Include(em => em.Episode)
+            .ThenInclude(e => e.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .OrderBy(em => em.EpisodeNumber)
+            .Skip((pageNumber - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync();
+    }
 
-        public async Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<int> maybeId = await dbContext.ShowMetadata
-                .Where(s => s.Title == metadata.Title && s.Year == metadata.Year)
-                .Where(s => s.Show.LibraryPathId == libraryPathId)
-                .SingleOrDefaultAsync()
-                .Map(Optional)
-                .MapT(sm => sm.ShowId);
+    public async Task<Option<Show>> GetShowByMetadata(int libraryPathId, ShowMetadata metadata)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<int> maybeId = await dbContext.ShowMetadata
+            .Where(s => s.Title == metadata.Title && s.Year == metadata.Year)
+            .Where(s => s.Show.LibraryPathId == libraryPathId)
+            .SingleOrDefaultAsync()
+            .Map(Optional)
+            .MapT(sm => sm.ShowId);
 
-            return await maybeId.Match(
-                id =>
-                {
-                    return dbContext.Shows
-                        .AsNoTracking()
-                        .Include(s => s.ShowMetadata)
-                        .ThenInclude(sm => sm.Artwork)
-                        .Include(s => s.ShowMetadata)
-                        .ThenInclude(sm => sm.Genres)
-                        .Include(s => s.ShowMetadata)
-                        .ThenInclude(sm => sm.Tags)
-                        .Include(s => s.ShowMetadata)
-                        .ThenInclude(sm => sm.Studios)
-                        .Include(s => s.ShowMetadata)
-                        .ThenInclude(sm => sm.Actors)
-                        .ThenInclude(a => a.Artwork)
-                        .Include(s => s.ShowMetadata)
-                        .ThenInclude(sm => sm.Guids)
-                        .Include(s => s.LibraryPath)
-                        .ThenInclude(lp => lp.Library)
-                        .Include(s => s.TraktListItems)
-                        .ThenInclude(tli => tli.TraktList)
-                        .OrderBy(s => s.Id)
-                        .SingleOrDefaultAsync(s => s.Id == id)
-                        .Map(Optional);
-                },
-                () => Option<Show>.None.AsTask());
-        }
-
-        public async Task<Either<BaseError, MediaItemScanResult<Show>>> AddShow(
-            int libraryPathId,
-            string showFolder,
-            ShowMetadata metadata)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-
-            try
+        return await maybeId.Match(
+            id =>
             {
-                metadata.DateAdded = DateTime.UtcNow;
-                metadata.Genres ??= new List<Genre>();
-                metadata.Tags ??= new List<Tag>();
-                metadata.Studios ??= new List<Studio>();
-                metadata.Actors ??= new List<Actor>();
-                metadata.Guids ??= new List<MetadataGuid>();
-                var show = new Show
-                {
-                    LibraryPathId = libraryPathId,
-                    ShowMetadata = new List<ShowMetadata> { metadata },
-                    Seasons = new List<Season>(),
-                    TraktListItems = new List<TraktListItem>()
-                };
+                return dbContext.Shows
+                    .AsNoTracking()
+                    .Include(s => s.ShowMetadata)
+                    .ThenInclude(sm => sm.Artwork)
+                    .Include(s => s.ShowMetadata)
+                    .ThenInclude(sm => sm.Genres)
+                    .Include(s => s.ShowMetadata)
+                    .ThenInclude(sm => sm.Tags)
+                    .Include(s => s.ShowMetadata)
+                    .ThenInclude(sm => sm.Studios)
+                    .Include(s => s.ShowMetadata)
+                    .ThenInclude(sm => sm.Actors)
+                    .ThenInclude(a => a.Artwork)
+                    .Include(s => s.ShowMetadata)
+                    .ThenInclude(sm => sm.Guids)
+                    .Include(s => s.LibraryPath)
+                    .ThenInclude(lp => lp.Library)
+                    .Include(s => s.TraktListItems)
+                    .ThenInclude(tli => tli.TraktList)
+                    .OrderBy(s => s.Id)
+                    .SingleOrDefaultAsync(s => s.Id == id)
+                    .Map(Optional);
+            },
+            () => Option<Show>.None.AsTask());
+    }
 
-                await dbContext.Shows.AddAsync(show);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(show).Reference(s => s.LibraryPath).LoadAsync();
-                await dbContext.Entry(show.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+    public async Task<Either<BaseError, MediaItemScanResult<Show>>> AddShow(
+        int libraryPathId,
+        string showFolder,
+        ShowMetadata metadata)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
 
-                return new MediaItemScanResult<Show>(show) { IsAdded = true };
-            }
-            catch (Exception ex)
+        try
+        {
+            metadata.DateAdded = DateTime.UtcNow;
+            metadata.Genres ??= new List<Genre>();
+            metadata.Tags ??= new List<Tag>();
+            metadata.Studios ??= new List<Studio>();
+            metadata.Actors ??= new List<Actor>();
+            metadata.Guids ??= new List<MetadataGuid>();
+            var show = new Show
             {
-                return BaseError.New(ex.Message);
-            }
+                LibraryPathId = libraryPathId,
+                ShowMetadata = new List<ShowMetadata> { metadata },
+                Seasons = new List<Season>(),
+                TraktListItems = new List<TraktListItem>()
+            };
+
+            await dbContext.Shows.AddAsync(show);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(show).Reference(s => s.LibraryPath).LoadAsync();
+            await dbContext.Entry(show.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+
+            return new MediaItemScanResult<Show>(show) { IsAdded = true };
         }
-
-        public async Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber)
+        catch (Exception ex)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<Season> maybeExisting = await dbContext.Seasons
-                .Include(s => s.SeasonMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(s => s.SeasonMetadata)
-                .ThenInclude(sm => sm.Guids)
-                .Include(s => s.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(s => s.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(s => s.ShowId)
-                .ThenBy(s => s.SeasonNumber)
-                .SingleOrDefaultAsync(s => s.ShowId == show.Id && s.SeasonNumber == seasonNumber);
-
-            return await maybeExisting.Match(
-                season => Right<BaseError, Season>(season).AsTask(),
-                () => AddSeason(dbContext, show, libraryPathId, seasonNumber));
+            return BaseError.New(ex.Message);
         }
+    }
 
-        public async Task<Either<BaseError, Episode>> GetOrAddEpisode(
-            Season season,
-            LibraryPath libraryPath,
-            string path)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<Episode> maybeExisting = await dbContext.Episodes
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(em => em.Artwork)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(em => em.Genres)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(em => em.Tags)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(em => em.Studios)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(em => em.Actors)
-                .ThenInclude(a => a.Artwork)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(em => em.Guids)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(i => i.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(i => i.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(i => i.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(i => i.Season)
-                .Include(i => i.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(i => i.MediaVersions.First().MediaFiles.First().Path)
-                .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
+    public async Task<Either<BaseError, Season>> GetOrAddSeason(Show show, int libraryPathId, int seasonNumber)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<Season> maybeExisting = await dbContext.Seasons
+            .Include(s => s.SeasonMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(s => s.SeasonMetadata)
+            .ThenInclude(sm => sm.Guids)
+            .Include(s => s.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(s => s.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(s => s.ShowId)
+            .ThenBy(s => s.SeasonNumber)
+            .SingleOrDefaultAsync(s => s.ShowId == show.Id && s.SeasonNumber == seasonNumber);
 
-            return await maybeExisting.Match<Task<Either<BaseError, Episode>>>(
-                async episode =>
+        return await maybeExisting.Match(
+            season => Right<BaseError, Season>(season).AsTask(),
+            () => AddSeason(dbContext, show, libraryPathId, seasonNumber));
+    }
+
+    public async Task<Either<BaseError, Episode>> GetOrAddEpisode(
+        Season season,
+        LibraryPath libraryPath,
+        string path)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<Episode> maybeExisting = await dbContext.Episodes
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(em => em.Artwork)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(em => em.Genres)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(em => em.Tags)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(em => em.Studios)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(em => em.Actors)
+            .ThenInclude(a => a.Artwork)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(em => em.Guids)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(i => i.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(i => i.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(i => i.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(i => i.Season)
+            .Include(i => i.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(i => i.MediaVersions.First().MediaFiles.First().Path)
+            .SingleOrDefaultAsync(i => i.MediaVersions.First().MediaFiles.First().Path == path);
+
+        return await maybeExisting.Match<Task<Either<BaseError, Episode>>>(
+            async episode =>
+            {
+                // move the file to the new season if needed
+                // this can happen when adding NFO metadata to existing content
+                if (episode.SeasonId != season.Id)
                 {
-                    // move the file to the new season if needed
-                    // this can happen when adding NFO metadata to existing content
-                    if (episode.SeasonId != season.Id)
-                    {
-                        episode.SeasonId = season.Id;
-                        episode.Season = season;
+                    episode.SeasonId = season.Id;
+                    episode.Season = season;
 
-                        await _dbConnection.ExecuteAsync(
-                            @"UPDATE Episode SET SeasonId = @SeasonId WHERE Id = @EpisodeId",
-                            new { SeasonId = season.Id, EpisodeId = episode.Id });
-                    }
+                    await _dbConnection.ExecuteAsync(
+                        @"UPDATE Episode SET SeasonId = @SeasonId WHERE Id = @EpisodeId",
+                        new { SeasonId = season.Id, EpisodeId = episode.Id });
+                }
 
-                    return episode;
-                },
-                async () => await AddEpisode(dbContext, season, libraryPath.Id, path));
-        }
+                return episode;
+            },
+            async () => await AddEpisode(dbContext, season, libraryPath.Id, path));
+    }
 
-        public Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath) =>
-            _dbConnection.QueryAsync<string>(
-                @"SELECT MF.Path
+    public Task<IEnumerable<string>> FindEpisodePaths(LibraryPath libraryPath) =>
+        _dbConnection.QueryAsync<string>(
+            @"SELECT MF.Path
                 FROM MediaFile MF
                 INNER JOIN MediaVersion MV on MF.MediaVersionId = MV.Id
                 INNER JOIN Episode E on MV.EpisodeId = E.Id
                 INNER JOIN MediaItem MI on E.Id = MI.Id
                 WHERE MI.LibraryPathId = @LibraryPathId",
-                new { LibraryPathId = libraryPath.Id });
+            new { LibraryPathId = libraryPath.Id });
 
-        public async Task<Unit> DeleteByPath(LibraryPath libraryPath, string path)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT E.Id
+    public async Task<Unit> DeleteByPath(LibraryPath libraryPath, string path)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT E.Id
                 FROM Episode E
                 INNER JOIN MediaItem MI on E.Id = MI.Id
                 INNER JOIN MediaVersion MV on E.Id = MV.EpisodeId
                 INNER JOIN MediaFile MF on MV.Id = MF.MediaVersionId
                 WHERE MI.LibraryPathId = @LibraryPathId AND MF.Path = @Path",
-                new { LibraryPathId = libraryPath.Id, Path = path });
+            new { LibraryPathId = libraryPath.Id, Path = path });
 
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            foreach (int episodeId in ids)
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        foreach (int episodeId in ids)
+        {
+            Episode episode = await dbContext.Episodes.FindAsync(episodeId);
+            if (episode != null)
             {
-                Episode episode = await dbContext.Episodes.FindAsync(episodeId);
-                if (episode != null)
-                {
-                    dbContext.Episodes.Remove(episode);
-                }
+                dbContext.Episodes.Remove(episode);
             }
-
-            await dbContext.SaveChangesAsync();
-
-            return Unit.Default;
         }
 
-        public async Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            List<Season> seasons = await dbContext.Seasons
-                .Filter(s => s.LibraryPathId == libraryPath.Id)
-                .Filter(s => s.Episodes.Count == 0)
-                .ToListAsync();
-            dbContext.Seasons.RemoveRange(seasons);
-            await dbContext.SaveChangesAsync();
-            return Unit.Default;
-        }
+        await dbContext.SaveChangesAsync();
 
-        public async Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            List<Show> shows = await dbContext.Shows
-                .Filter(s => s.LibraryPathId == libraryPath.Id)
-                .Filter(s => s.Seasons.Count == 0)
-                .ToListAsync();
-            var ids = shows.Map(s => s.Id).ToList();
-            dbContext.Shows.RemoveRange(shows);
-            await dbContext.SaveChangesAsync();
-            return ids;
-        }
+        return Unit.Default;
+    }
 
-        public async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(
-            PlexLibrary library,
-            PlexShow item)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<PlexShow> maybeExisting = await dbContext.PlexShows
-                .AsNoTracking()
-                .Include(i => i.ShowMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(i => i.ShowMetadata)
-                .ThenInclude(sm => sm.Tags)
-                .Include(i => i.ShowMetadata)
-                .ThenInclude(sm => sm.Studios)
-                .Include(i => i.ShowMetadata)
-                .ThenInclude(sm => sm.Actors)
-                .ThenInclude(a => a.Artwork)
-                .Include(i => i.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(i => i.ShowMetadata)
-                .ThenInclude(sm => sm.Guids)
-                .Include(i => i.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(i => i.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(i => i.Key)
-                .SingleOrDefaultAsync(i => i.Key == item.Key);
+    public async Task<Unit> DeleteEmptySeasons(LibraryPath libraryPath)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        List<Season> seasons = await dbContext.Seasons
+            .Filter(s => s.LibraryPathId == libraryPath.Id)
+            .Filter(s => s.Episodes.Count == 0)
+            .ToListAsync();
+        dbContext.Seasons.RemoveRange(seasons);
+        await dbContext.SaveChangesAsync();
+        return Unit.Default;
+    }
 
-            return await maybeExisting.Match(
-                plexShow => Right<BaseError, MediaItemScanResult<PlexShow>>(
-                    new MediaItemScanResult<PlexShow>(plexShow) { IsAdded = false }).AsTask(),
-                async () => await AddPlexShow(dbContext, library, item));
-        }
+    public async Task<List<int>> DeleteEmptyShows(LibraryPath libraryPath)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        List<Show> shows = await dbContext.Shows
+            .Filter(s => s.LibraryPathId == libraryPath.Id)
+            .Filter(s => s.Seasons.Count == 0)
+            .ToListAsync();
+        var ids = shows.Map(s => s.Id).ToList();
+        dbContext.Shows.RemoveRange(shows);
+        await dbContext.SaveChangesAsync();
+        return ids;
+    }
 
-        public async Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<PlexSeason> maybeExisting = await dbContext.PlexSeasons
-                .AsNoTracking()
-                .Include(i => i.SeasonMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(i => i.SeasonMetadata)
-                .ThenInclude(sm => sm.Guids)
-                .Include(s => s.LibraryPath)
-                .ThenInclude(l => l.Library)
-                .Include(s => s.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(i => i.Key)
-                .SingleOrDefaultAsync(i => i.Key == item.Key);
+    public async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> GetOrAddPlexShow(
+        PlexLibrary library,
+        PlexShow item)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<PlexShow> maybeExisting = await dbContext.PlexShows
+            .AsNoTracking()
+            .Include(i => i.ShowMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(i => i.ShowMetadata)
+            .ThenInclude(sm => sm.Tags)
+            .Include(i => i.ShowMetadata)
+            .ThenInclude(sm => sm.Studios)
+            .Include(i => i.ShowMetadata)
+            .ThenInclude(sm => sm.Actors)
+            .ThenInclude(a => a.Artwork)
+            .Include(i => i.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(i => i.ShowMetadata)
+            .ThenInclude(sm => sm.Guids)
+            .Include(i => i.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(i => i.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(i => i.Key)
+            .SingleOrDefaultAsync(i => i.Key == item.Key);
 
-            return await maybeExisting.Match(
-                plexSeason => Right<BaseError, PlexSeason>(plexSeason).AsTask(),
-                async () => await AddPlexSeason(dbContext, library, item));
-        }
+        return await maybeExisting.Match(
+            plexShow => Right<BaseError, MediaItemScanResult<PlexShow>>(
+                new MediaItemScanResult<PlexShow>(plexShow) { IsAdded = false }).AsTask(),
+            async () => await AddPlexShow(dbContext, library, item));
+    }
 
-        public async Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item)
-        {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            Option<PlexEpisode> maybeExisting = await dbContext.PlexEpisodes
-                .AsNoTracking()
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(mm => mm.Tags)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(mm => mm.Studios)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(mm => mm.Directors)
-                .Include(i => i.EpisodeMetadata)
-                .ThenInclude(mm => mm.Writers)
-                .Include(i => i.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(i => i.MediaVersions)
-                .ThenInclude(mv => mv.Streams)
-                .Include(e => e.EpisodeMetadata)
-                .ThenInclude(em => em.Actors)
-                .ThenInclude(a => a.Artwork)
-                .Include(e => e.EpisodeMetadata)
-                .ThenInclude(em => em.Guids)
-                .Include(i => i.LibraryPath)
-                .ThenInclude(lp => lp.Library)
-                .Include(e => e.Season)
-                .Include(e => e.TraktListItems)
-                .ThenInclude(tli => tli.TraktList)
-                .OrderBy(i => i.Key)
-                .SingleOrDefaultAsync(i => i.Key == item.Key);
+    public async Task<Either<BaseError, PlexSeason>> GetOrAddPlexSeason(PlexLibrary library, PlexSeason item)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<PlexSeason> maybeExisting = await dbContext.PlexSeasons
+            .AsNoTracking()
+            .Include(i => i.SeasonMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(i => i.SeasonMetadata)
+            .ThenInclude(sm => sm.Guids)
+            .Include(s => s.LibraryPath)
+            .ThenInclude(l => l.Library)
+            .Include(s => s.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(i => i.Key)
+            .SingleOrDefaultAsync(i => i.Key == item.Key);
 
-            return await maybeExisting.Match(
-                plexEpisode => Right<BaseError, PlexEpisode>(plexEpisode).AsTask(),
-                async () => await AddPlexEpisode(dbContext, library, item));
-        }
+        return await maybeExisting.Match(
+            plexSeason => Right<BaseError, PlexSeason>(plexSeason).AsTask(),
+            async () => await AddPlexSeason(dbContext, library, item));
+    }
 
-        public Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys) =>
-            _dbConnection.ExecuteAsync(
-                @"DELETE FROM MediaItem WHERE Id IN
+    public async Task<Either<BaseError, PlexEpisode>> GetOrAddPlexEpisode(PlexLibrary library, PlexEpisode item)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        Option<PlexEpisode> maybeExisting = await dbContext.PlexEpisodes
+            .AsNoTracking()
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(mm => mm.Tags)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(mm => mm.Studios)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(mm => mm.Directors)
+            .Include(i => i.EpisodeMetadata)
+            .ThenInclude(mm => mm.Writers)
+            .Include(i => i.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(i => i.MediaVersions)
+            .ThenInclude(mv => mv.Streams)
+            .Include(e => e.EpisodeMetadata)
+            .ThenInclude(em => em.Actors)
+            .ThenInclude(a => a.Artwork)
+            .Include(e => e.EpisodeMetadata)
+            .ThenInclude(em => em.Guids)
+            .Include(i => i.LibraryPath)
+            .ThenInclude(lp => lp.Library)
+            .Include(e => e.Season)
+            .Include(e => e.TraktListItems)
+            .ThenInclude(tli => tli.TraktList)
+            .OrderBy(i => i.Key)
+            .SingleOrDefaultAsync(i => i.Key == item.Key);
+
+        return await maybeExisting.Match(
+            plexEpisode => Right<BaseError, PlexEpisode>(plexEpisode).AsTask(),
+            async () => await AddPlexEpisode(dbContext, library, item));
+    }
+
+    public Task<Unit> RemoveMissingPlexSeasons(string showKey, List<string> seasonKeys) =>
+        _dbConnection.ExecuteAsync(
+            @"DELETE FROM MediaItem WHERE Id IN
                 (SELECT m.Id FROM MediaItem m
                 INNER JOIN Season s ON m.Id = s.Id
                 INNER JOIN PlexSeason ps ON ps.Id = m.Id
                 INNER JOIN PlexShow P on P.Id = s.ShowId
                 WHERE P.Key = @ShowKey AND ps.Key not in @Keys)",
-                new { ShowKey = showKey, Keys = seasonKeys }).ToUnit();
+            new { ShowKey = showKey, Keys = seasonKeys }).ToUnit();
 
-        public async Task<List<int>> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+    public async Task<List<int>> RemoveMissingPlexEpisodes(string seasonKey, List<string> episodeKeys)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN Episode e ON m.Id = e.Id
                 INNER JOIN PlexEpisode pe ON pe.Id = m.Id
                 INNER JOIN PlexSeason P on P.Id = e.SeasonId
                 WHERE P.Key = @SeasonKey AND pe.Key not in @Keys",
-                new { SeasonKey = seasonKey, Keys = episodeKeys }).Map(result => result.ToList());
+            new { SeasonKey = seasonKey, Keys = episodeKeys }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
-        }
+        return ids;
+    }
 
-        public async Task<Unit> RemoveMetadata(Episode episode, EpisodeMetadata metadata)
-        {
-            episode.EpisodeMetadata.Remove(metadata);
-            await _dbConnection.ExecuteAsync(
-                @"DELETE FROM EpisodeMetadata WHERE Id = @MetadataId",
-                new { MetadataId = metadata.Id });
-            return Unit.Default;
-        }
+    public async Task<Unit> RemoveMetadata(Episode episode, EpisodeMetadata metadata)
+    {
+        episode.EpisodeMetadata.Remove(metadata);
+        await _dbConnection.ExecuteAsync(
+            @"DELETE FROM EpisodeMetadata WHERE Id = @MetadataId",
+            new { MetadataId = metadata.Id });
+        return Unit.Default;
+    }
 
-        public Task<bool> AddDirector(EpisodeMetadata metadata, Director director) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Director (Name, EpisodeMetadataId) VALUES (@Name, @MetadataId)",
-                new { director.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+    public Task<bool> AddDirector(EpisodeMetadata metadata, Director director) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Director (Name, EpisodeMetadataId) VALUES (@Name, @MetadataId)",
+            new { director.Name, MetadataId = metadata.Id }).Map(result => result > 0);
 
-        public Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Writer (Name, EpisodeMetadataId) VALUES (@Name, @MetadataId)",
-                new { writer.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+    public Task<bool> AddWriter(EpisodeMetadata metadata, Writer writer) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Writer (Name, EpisodeMetadataId) VALUES (@Name, @MetadataId)",
+            new { writer.Name, MetadataId = metadata.Id }).Map(result => result > 0);
 
-        public Task<Unit> UpdatePath(int mediaFileId, string path) =>
-            _dbConnection.ExecuteAsync(
-                "UPDATE MediaFile SET Path = @Path WHERE Id = @MediaFileId",
-                new { Path = path, MediaFileId = mediaFileId }).Map(_ => Unit.Default);
+    public Task<Unit> UpdatePath(int mediaFileId, string path) =>
+        _dbConnection.ExecuteAsync(
+            "UPDATE MediaFile SET Path = @Path WHERE Id = @MediaFileId",
+            new { Path = path, MediaFileId = mediaFileId }).Map(_ => Unit.Default);
 
-        public async Task<List<Episode>> GetShowItems(int showId)
-        {
-            IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT Episode.Id FROM Show
+    public async Task<List<Episode>> GetShowItems(int showId)
+    {
+        IEnumerable<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT Episode.Id FROM Show
             INNER JOIN Season ON Season.ShowId = Show.Id
             INNER JOIN Episode ON Episode.SeasonId = Season.Id
             WHERE Show.Id = @ShowId",
-                new { ShowId = showId });
+            new { ShowId = showId });
 
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Episodes
-                .AsNoTracking()
-                .Include(e => e.EpisodeMetadata)
-                .Include(e => e.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(e => e.Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Filter(e => ids.Contains(e.Id))
-                .ToListAsync();
-        }
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Episodes
+            .AsNoTracking()
+            .Include(e => e.EpisodeMetadata)
+            .Include(e => e.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(e => e.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Filter(e => ids.Contains(e.Id))
+            .ToListAsync();
+    }
 
-        public async Task<List<Episode>> GetSeasonItems(int seasonId)
+    public async Task<List<Episode>> GetSeasonItems(int seasonId)
+    {
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        return await dbContext.Episodes
+            .AsNoTracking()
+            .Include(e => e.EpisodeMetadata)
+            .Include(e => e.MediaVersions)
+            .ThenInclude(mv => mv.Chapters)
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .Include(e => e.Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .Filter(e => e.SeasonId == seasonId)
+            .ToListAsync();
+    }
+
+    public Task<bool> AddGenre(ShowMetadata metadata, Genre genre) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Genre (Name, ShowMetadataId) VALUES (@Name, @MetadataId)",
+            new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddTag(ShowMetadata metadata, Tag tag) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Tag (Name, ShowMetadataId) VALUES (@Name, @MetadataId)",
+            new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public Task<bool> AddStudio(ShowMetadata metadata, Studio studio) =>
+        _dbConnection.ExecuteAsync(
+            "INSERT INTO Studio (Name, ShowMetadataId) VALUES (@Name, @MetadataId)",
+            new { studio.Name, MetadataId = metadata.Id }).Map(result => result > 0);
+
+    public async Task<bool> AddActor(ShowMetadata metadata, Actor actor)
+    {
+        int? artworkId = null;
+
+        if (actor.Artwork != null)
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
-            return await dbContext.Episodes
-                .AsNoTracking()
-                .Include(e => e.EpisodeMetadata)
-                .Include(e => e.MediaVersions)
-                .ThenInclude(mv => mv.Chapters)
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .Include(e => e.Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .Filter(e => e.SeasonId == seasonId)
-                .ToListAsync();
-        }
-
-        public Task<bool> AddGenre(ShowMetadata metadata, Genre genre) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Genre (Name, ShowMetadataId) VALUES (@Name, @MetadataId)",
-                new { genre.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddTag(ShowMetadata metadata, Tag tag) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Tag (Name, ShowMetadataId) VALUES (@Name, @MetadataId)",
-                new { tag.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public Task<bool> AddStudio(ShowMetadata metadata, Studio studio) =>
-            _dbConnection.ExecuteAsync(
-                "INSERT INTO Studio (Name, ShowMetadataId) VALUES (@Name, @MetadataId)",
-                new { studio.Name, MetadataId = metadata.Id }).Map(result => result > 0);
-
-        public async Task<bool> AddActor(ShowMetadata metadata, Actor actor)
-        {
-            int? artworkId = null;
-
-            if (actor.Artwork != null)
-            {
-                artworkId = await _dbConnection.QuerySingleAsync<int>(
-                    @"INSERT INTO Artwork (ArtworkKind, DateAdded, DateUpdated, Path)
+            artworkId = await _dbConnection.QuerySingleAsync<int>(
+                @"INSERT INTO Artwork (ArtworkKind, DateAdded, DateUpdated, Path)
                       VALUES (@ArtworkKind, @DateAdded, @DateUpdated, @Path);
                       SELECT last_insert_rowid()",
-                    new
-                    {
-                        ArtworkKind = (int) actor.Artwork.ArtworkKind,
-                        actor.Artwork.DateAdded,
-                        actor.Artwork.DateUpdated,
-                        actor.Artwork.Path
-                    });
-            }
-
-            return await _dbConnection.ExecuteAsync(
-                    "INSERT INTO Actor (Name, Role, \"Order\", ShowMetadataId, ArtworkId) VALUES (@Name, @Role, @Order, @MetadataId, @ArtworkId)",
-                    new { actor.Name, actor.Role, actor.Order, MetadataId = metadata.Id, ArtworkId = artworkId })
-                .Map(result => result > 0);
+                new
+                {
+                    ArtworkKind = (int) actor.Artwork.ArtworkKind,
+                    actor.Artwork.DateAdded,
+                    actor.Artwork.DateUpdated,
+                    actor.Artwork.Path
+                });
         }
 
-        public async Task<bool> AddActor(EpisodeMetadata metadata, Actor actor)
-        {
-            int? artworkId = null;
+        return await _dbConnection.ExecuteAsync(
+                "INSERT INTO Actor (Name, Role, \"Order\", ShowMetadataId, ArtworkId) VALUES (@Name, @Role, @Order, @MetadataId, @ArtworkId)",
+                new { actor.Name, actor.Role, actor.Order, MetadataId = metadata.Id, ArtworkId = artworkId })
+            .Map(result => result > 0);
+    }
 
-            if (actor.Artwork != null)
-            {
-                artworkId = await _dbConnection.QuerySingleAsync<int>(
-                    @"INSERT INTO Artwork (ArtworkKind, DateAdded, DateUpdated, Path)
+    public async Task<bool> AddActor(EpisodeMetadata metadata, Actor actor)
+    {
+        int? artworkId = null;
+
+        if (actor.Artwork != null)
+        {
+            artworkId = await _dbConnection.QuerySingleAsync<int>(
+                @"INSERT INTO Artwork (ArtworkKind, DateAdded, DateUpdated, Path)
                       VALUES (@ArtworkKind, @DateAdded, @DateUpdated, @Path);
                       SELECT last_insert_rowid()",
-                    new
-                    {
-                        ArtworkKind = (int) actor.Artwork.ArtworkKind,
-                        actor.Artwork.DateAdded,
-                        actor.Artwork.DateUpdated,
-                        actor.Artwork.Path
-                    });
-            }
-
-            return await _dbConnection.ExecuteAsync(
-                    "INSERT INTO Actor (Name, Role, \"Order\", EpisodeMetadataId, ArtworkId) VALUES (@Name, @Role, @Order, @MetadataId, @ArtworkId)",
-                    new { actor.Name, actor.Role, actor.Order, MetadataId = metadata.Id, ArtworkId = artworkId })
-                .Map(result => result > 0);
+                new
+                {
+                    ArtworkKind = (int) actor.Artwork.ArtworkKind,
+                    actor.Artwork.DateAdded,
+                    actor.Artwork.DateUpdated,
+                    actor.Artwork.Path
+                });
         }
 
-        public async Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys)
-        {
-            List<int> ids = await _dbConnection.QueryAsync<int>(
-                @"SELECT m.Id FROM MediaItem m
+        return await _dbConnection.ExecuteAsync(
+                "INSERT INTO Actor (Name, Role, \"Order\", EpisodeMetadataId, ArtworkId) VALUES (@Name, @Role, @Order, @MetadataId, @ArtworkId)",
+                new { actor.Name, actor.Role, actor.Order, MetadataId = metadata.Id, ArtworkId = artworkId })
+            .Map(result => result > 0);
+    }
+
+    public async Task<List<int>> RemoveMissingPlexShows(PlexLibrary library, List<string> showKeys)
+    {
+        List<int> ids = await _dbConnection.QueryAsync<int>(
+            @"SELECT m.Id FROM MediaItem m
                 INNER JOIN PlexShow ps ON ps.Id = m.Id
                 INNER JOIN LibraryPath lp ON lp.Id = m.LibraryPathId
                 WHERE lp.LibraryId = @LibraryId AND ps.Key not in @Keys",
-                new { LibraryId = library.Id, Keys = showKeys }).Map(result => result.ToList());
+            new { LibraryId = library.Id, Keys = showKeys }).Map(result => result.ToList());
 
-            await _dbConnection.ExecuteAsync(
-                "DELETE FROM MediaItem WHERE Id IN @Ids",
-                new { Ids = ids });
+        await _dbConnection.ExecuteAsync(
+            "DELETE FROM MediaItem WHERE Id IN @Ids",
+            new { Ids = ids });
 
-            return ids;
-        }
+        return ids;
+    }
 
-        private static async Task<Either<BaseError, Season>> AddSeason(
-            TvContext dbContext,
-            Show show,
-            int libraryPathId,
-            int seasonNumber)
+    private static async Task<Either<BaseError, Season>> AddSeason(
+        TvContext dbContext,
+        Show show,
+        int libraryPathId,
+        int seasonNumber)
+    {
+        try
         {
-            try
+            var season = new Season
             {
-                var season = new Season
+                LibraryPathId = libraryPathId,
+                ShowId = show.Id,
+                SeasonNumber = seasonNumber,
+                Episodes = new List<Episode>(),
+                SeasonMetadata = new List<SeasonMetadata>
                 {
-                    LibraryPathId = libraryPathId,
-                    ShowId = show.Id,
-                    SeasonNumber = seasonNumber,
-                    Episodes = new List<Episode>(),
-                    SeasonMetadata = new List<SeasonMetadata>
+                    new()
                     {
-                        new()
-                        {
-                            DateAdded = DateTime.UtcNow,
-                            Guids = new List<MetadataGuid>()
-                        }
-                    },
-                    TraktListItems = new List<TraktListItem>()
-                };
-                await dbContext.Seasons.AddAsync(season);
-                await dbContext.SaveChangesAsync();
+                        DateAdded = DateTime.UtcNow,
+                        Guids = new List<MetadataGuid>()
+                    }
+                },
+                TraktListItems = new List<TraktListItem>()
+            };
+            await dbContext.Seasons.AddAsync(season);
+            await dbContext.SaveChangesAsync();
 
-                await dbContext.Entry(season).Reference(s => s.LibraryPath).LoadAsync();
-                await dbContext.Entry(season.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            await dbContext.Entry(season).Reference(s => s.LibraryPath).LoadAsync();
+            await dbContext.Entry(season.LibraryPath).Reference(lp => lp.Library).LoadAsync();
                 
-                return season;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
+            return season;
         }
-
-        private static async Task<Either<BaseError, Episode>> AddEpisode(
-            TvContext dbContext,
-            Season season,
-            int libraryPathId,
-            string path)
+        catch (Exception ex)
         {
-            try
-            {
-                if (dbContext.MediaFiles.Any(mf => mf.Path == path))
-                {
-                    return BaseError.New("Multi-episode files are not yet supported");
-                }
-
-                var episode = new Episode
-                {
-                    LibraryPathId = libraryPathId,
-                    SeasonId = season.Id,
-                    EpisodeMetadata = new List<EpisodeMetadata>
-                    {
-                        new()
-                        {
-                            DateAdded = DateTime.UtcNow,
-                            DateUpdated = SystemTime.MinValueUtc,
-                            MetadataKind = MetadataKind.Fallback,
-                            Actors = new List<Actor>(),
-                            Guids = new List<MetadataGuid>(),
-                            Writers = new List<Writer>(),
-                            Directors = new List<Director>(),
-                            Genres = new List<Genre>(),
-                            Tags = new List<Tag>(),
-                            Studios = new List<Studio>()
-                        }
-                    },
-                    MediaVersions = new List<MediaVersion>
-                    {
-                        new()
-                        {
-                            MediaFiles = new List<MediaFile>
-                            {
-                                new() { Path = path }
-                            },
-                            Streams = new List<MediaStream>()
-                        }
-                    },
-                    TraktListItems = new List<TraktListItem>()
-                };
-                await dbContext.Episodes.AddAsync(episode);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(episode).Reference(i => i.LibraryPath).LoadAsync();
-                await dbContext.Entry(episode.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                await dbContext.Entry(episode).Reference(e => e.Season).LoadAsync();
-                return episode;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        private static async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> AddPlexShow(
-            TvContext dbContext,
-            PlexLibrary library,
-            PlexShow item)
-        {
-            try
-            {
-                item.LibraryPathId = library.Paths.Head().Id;
-
-                await dbContext.PlexShows.AddAsync(item);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(item).Reference(i => i.LibraryPath).LoadAsync();
-                await dbContext.Entry(item.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return new MediaItemScanResult<PlexShow>(item) { IsAdded = true };
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        private static async Task<Either<BaseError, PlexSeason>> AddPlexSeason(
-            TvContext dbContext,
-            PlexLibrary library,
-            PlexSeason item)
-        {
-            try
-            {
-                item.LibraryPathId = library.Paths.Head().Id;
-
-                await dbContext.PlexSeasons.AddAsync(item);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(item).Reference(i => i.LibraryPath).LoadAsync();
-                await dbContext.Entry(item.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                return item;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        private static async Task<Either<BaseError, PlexEpisode>> AddPlexEpisode(
-            TvContext dbContext,
-            PlexLibrary library,
-            PlexEpisode item)
-        {
-            try
-            {
-                if (dbContext.MediaFiles.Any(mf => mf.Path == item.MediaVersions.Head().MediaFiles.Head().Path))
-                {
-                    return BaseError.New("Multi-episode files are not yet supported");
-                }
-
-                item.LibraryPathId = library.Paths.Head().Id;
-                foreach (EpisodeMetadata metadata in item.EpisodeMetadata)
-                {
-                    metadata.Genres ??= new List<Genre>();
-                    metadata.Tags ??= new List<Tag>();
-                    metadata.Studios ??= new List<Studio>();
-                    metadata.Actors ??= new List<Actor>();
-                    metadata.Directors ??= new List<Director>();
-                    metadata.Writers ??= new List<Writer>();
-                }
-
-                await dbContext.PlexEpisodes.AddAsync(item);
-                await dbContext.SaveChangesAsync();
-                await dbContext.Entry(item).Reference(i => i.LibraryPath).LoadAsync();
-                await dbContext.Entry(item.LibraryPath).Reference(lp => lp.Library).LoadAsync();
-                await dbContext.Entry(item).Reference(e => e.Season).LoadAsync();
-                return item;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
+            return BaseError.New(ex.Message);
         }
     }
-}
+
+    private static async Task<Either<BaseError, Episode>> AddEpisode(
+        TvContext dbContext,
+        Season season,
+        int libraryPathId,
+        string path)
+    {
+        try
+        {
+            if (dbContext.MediaFiles.Any(mf => mf.Path == path))
+            {
+                return BaseError.New("Multi-episode files are not yet supported");
+            }
+
+            var episode = new Episode
+            {
+                LibraryPathId = libraryPathId,
+                SeasonId = season.Id,
+                EpisodeMetadata = new List<EpisodeMetadata>
+                {
+                    new()
+                    {
+                        DateAdded = DateTime.UtcNow,
+                        DateUpdated = SystemTime.MinValueUtc,
+                        MetadataKind = MetadataKind.Fallback,
+                        Actors = new List<Actor>(),
+                        Guids = new List<MetadataGuid>(),
+                        Writers = new List<Writer>(),
+                        Directors = new List<Director>(),
+                        Genres = new List<Genre>(),
+                        Tags = new List<Tag>(),
+                        Studios = new List<Studio>()
+                    }
+                },
+                MediaVersions = new List<MediaVersion>
+                {
+                    new()
+                    {
+                        MediaFiles = new List<MediaFile>
+                        {
+                            new() { Path = path }
+                        },
+                        Streams = new List<MediaStream>()
+                    }
+                },
+                TraktListItems = new List<TraktListItem>()
+            };
+            await dbContext.Episodes.AddAsync(episode);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(episode).Reference(i => i.LibraryPath).LoadAsync();
+            await dbContext.Entry(episode.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            await dbContext.Entry(episode).Reference(e => e.Season).LoadAsync();
+            return episode;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    private static async Task<Either<BaseError, MediaItemScanResult<PlexShow>>> AddPlexShow(
+        TvContext dbContext,
+        PlexLibrary library,
+        PlexShow item)
+    {
+        try
+        {
+            item.LibraryPathId = library.Paths.Head().Id;
+
+            await dbContext.PlexShows.AddAsync(item);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(item).Reference(i => i.LibraryPath).LoadAsync();
+            await dbContext.Entry(item.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            return new MediaItemScanResult<PlexShow>(item) { IsAdded = true };
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    private static async Task<Either<BaseError, PlexSeason>> AddPlexSeason(
+        TvContext dbContext,
+        PlexLibrary library,
+        PlexSeason item)
+    {
+        try
+        {
+            item.LibraryPathId = library.Paths.Head().Id;
+
+            await dbContext.PlexSeasons.AddAsync(item);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(item).Reference(i => i.LibraryPath).LoadAsync();
+            await dbContext.Entry(item.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            return item;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    private static async Task<Either<BaseError, PlexEpisode>> AddPlexEpisode(
+        TvContext dbContext,
+        PlexLibrary library,
+        PlexEpisode item)
+    {
+        try
+        {
+            if (dbContext.MediaFiles.Any(mf => mf.Path == item.MediaVersions.Head().MediaFiles.Head().Path))
+            {
+                return BaseError.New("Multi-episode files are not yet supported");
+            }
+
+            item.LibraryPathId = library.Paths.Head().Id;
+            foreach (EpisodeMetadata metadata in item.EpisodeMetadata)
+            {
+                metadata.Genres ??= new List<Genre>();
+                metadata.Tags ??= new List<Tag>();
+                metadata.Studios ??= new List<Studio>();
+                metadata.Actors ??= new List<Actor>();
+                metadata.Directors ??= new List<Director>();
+                metadata.Writers ??= new List<Writer>();
+            }
+
+            await dbContext.PlexEpisodes.AddAsync(item);
+            await dbContext.SaveChangesAsync();
+            await dbContext.Entry(item).Reference(i => i.LibraryPath).LoadAsync();
+            await dbContext.Entry(item.LibraryPath).Reference(lp => lp.Library).LoadAsync();
+            await dbContext.Entry(item).Reference(e => e.Season).LoadAsync();
+            return item;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/SqliteTypeHandlers.cs b/ErsatzTV.Infrastructure/Data/SqliteTypeHandlers.cs
index 3fe2ece00..9970971bd 100644
--- a/ErsatzTV.Infrastructure/Data/SqliteTypeHandlers.cs
+++ b/ErsatzTV.Infrastructure/Data/SqliteTypeHandlers.cs
@@ -1,31 +1,29 @@
-using System;
-using System.Data;
+using System.Data;
 using Dapper;
 
-namespace ErsatzTV.Infrastructure.Data
+namespace ErsatzTV.Infrastructure.Data;
+
+public abstract class SqliteTypeHandler<T> : SqlMapper.TypeHandler<T>
 {
-    public abstract class SqliteTypeHandler<T> : SqlMapper.TypeHandler<T>
-    {
-        // Parameters are converted by Microsoft.Data.Sqlite
-        public override void SetValue(IDbDataParameter parameter, T value)
-            => parameter.Value = value;
-    }
-
-    public class DateTimeOffsetHandler : SqliteTypeHandler<DateTimeOffset>
-    {
-        public override DateTimeOffset Parse(object value)
-            => DateTimeOffset.Parse((string) value);
-    }
-
-    public class GuidHandler : SqliteTypeHandler<Guid>
-    {
-        public override Guid Parse(object value)
-            => Guid.Parse((string) value);
-    }
-
-    public class TimeSpanHandler : SqliteTypeHandler<TimeSpan>
-    {
-        public override TimeSpan Parse(object value)
-            => TimeSpan.Parse((string) value);
-    }
+    // Parameters are converted by Microsoft.Data.Sqlite
+    public override void SetValue(IDbDataParameter parameter, T value)
+        => parameter.Value = value;
 }
+
+public class DateTimeOffsetHandler : SqliteTypeHandler<DateTimeOffset>
+{
+    public override DateTimeOffset Parse(object value)
+        => DateTimeOffset.Parse((string) value);
+}
+
+public class GuidHandler : SqliteTypeHandler<Guid>
+{
+    public override Guid Parse(object value)
+        => Guid.Parse((string) value);
+}
+
+public class TimeSpanHandler : SqliteTypeHandler<TimeSpan>
+{
+    public override TimeSpan Parse(object value)
+        => TimeSpan.Parse((string) value);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Data/TvContext.cs b/ErsatzTV.Infrastructure/Data/TvContext.cs
index 101ed91be..c16d7c70d 100644
--- a/ErsatzTV.Infrastructure/Data/TvContext.cs
+++ b/ErsatzTV.Infrastructure/Data/TvContext.cs
@@ -3,90 +3,89 @@ using ErsatzTV.Core.Domain.Filler;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Infrastructure.Data
+namespace ErsatzTV.Infrastructure.Data;
+
+public class TvContext : DbContext
 {
-    public class TvContext : DbContext
+    private readonly ILoggerFactory _loggerFactory;
+
+    public TvContext(DbContextOptions<TvContext> options, ILoggerFactory loggerFactory)
+        : base(options) =>
+        _loggerFactory = loggerFactory;
+
+    public DbSet<ConfigElement> ConfigElements { get; set; }
+    public DbSet<Channel> Channels { get; set; }
+    public DbSet<ChannelWatermark> ChannelWatermarks { get; set; }
+    public DbSet<MediaSource> MediaSources { get; set; }
+    public DbSet<LocalMediaSource> LocalMediaSources { get; set; }
+    public DbSet<PlexMediaSource> PlexMediaSources { get; set; }
+    public DbSet<JellyfinMediaSource> JellyfinMediaSources { get; set; }
+    public DbSet<EmbyMediaSource> EmbyMediaSources { get; set; }
+    public DbSet<Library> Libraries { get; set; }
+    public DbSet<LocalLibrary> LocalLibraries { get; set; }
+    public DbSet<LibraryPath> LibraryPaths { get; set; }
+    public DbSet<LibraryFolder> LibraryFolders { get; set; }
+    public DbSet<PlexLibrary> PlexLibraries { get; set; }
+    public DbSet<JellyfinLibrary> JellyfinLibraries { get; set; }
+    public DbSet<EmbyLibrary> EmbyLibraries { get; set; }
+    public DbSet<PlexPathReplacement> PlexPathReplacements { get; set; }
+    public DbSet<JellyfinPathReplacement> JellyfinPathReplacements { get; set; }
+    public DbSet<EmbyPathReplacement> EmbyPathReplacements { get; set; }
+    public DbSet<MediaItem> MediaItems { get; set; }
+    public DbSet<MediaVersion> MediaVersions { get; set; }
+    public DbSet<MediaFile> MediaFiles { get; set; }
+    public DbSet<MediaStream> MediaStreams { get; set; }
+    public DbSet<Movie> Movies { get; set; }
+    public DbSet<MovieMetadata> MovieMetadata { get; set; }
+    public DbSet<Artwork> Artwork { get; set; }
+    public DbSet<Artist> Artists { get; set; }
+    public DbSet<ArtistMetadata> ArtistMetadata { get; set; }
+    public DbSet<MusicVideo> MusicVideos { get; set; }
+    public DbSet<MusicVideoMetadata> MusicVideoMetadata { get; set; }
+    public DbSet<OtherVideo> OtherVideos { get; set; }
+    public DbSet<OtherVideoMetadata> OtherVideoMetadata { get; set; }
+    public DbSet<Song> Songs { get; set; }
+    public DbSet<SongMetadata> SongMetadata { get; set; }
+    public DbSet<Show> Shows { get; set; }
+    public DbSet<ShowMetadata> ShowMetadata { get; set; }
+    public DbSet<Season> Seasons { get; set; }
+    public DbSet<SeasonMetadata> SeasonMetadata { get; set; }
+    public DbSet<Episode> Episodes { get; set; }
+    public DbSet<EpisodeMetadata> EpisodeMetadata { get; set; }
+    public DbSet<PlexMovie> PlexMovies { get; set; }
+    public DbSet<PlexShow> PlexShows { get; set; }
+    public DbSet<PlexSeason> PlexSeasons { get; set; }
+    public DbSet<PlexEpisode> PlexEpisodes { get; set; }
+    public DbSet<JellyfinMovie> JellyfinMovies { get; set; }
+    public DbSet<JellyfinShow> JellyfinShows { get; set; }
+    public DbSet<JellyfinSeason> JellyfinSeasons { get; set; }
+    public DbSet<JellyfinEpisode> JellyfinEpisodes { get; set; }
+    public DbSet<EmbyMovie> EmbyMovies { get; set; }
+    public DbSet<EmbyShow> EmbyShows { get; set; }
+    public DbSet<EmbySeason> EmbySeasons { get; set; }
+    public DbSet<EmbyEpisode> EmbyEpisodes { get; set; }
+    public DbSet<Collection> Collections { get; set; }
+    public DbSet<CollectionItem> CollectionItems { get; set; }
+    public DbSet<MultiCollection> MultiCollections { get; set; }
+    public DbSet<SmartCollection> SmartCollections { get; set; }
+    public DbSet<ProgramSchedule> ProgramSchedules { get; set; }
+    public DbSet<ProgramScheduleItem> ProgramScheduleItems { get; set; }
+    public DbSet<Playout> Playouts { get; set; }
+    public DbSet<PlayoutItem> PlayoutItems { get; set; }
+    public DbSet<PlayoutProgramScheduleAnchor> PlayoutProgramScheduleItemAnchors { get; set; }
+    public DbSet<FFmpegProfile> FFmpegProfiles { get; set; }
+    public DbSet<Resolution> Resolutions { get; set; }
+    public DbSet<LanguageCode> LanguageCodes { get; set; }
+    public DbSet<TraktList> TraktLists { get; set; }
+    public DbSet<FillerPreset> FillerPresets { get; set; }
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) =>
+        optionsBuilder.UseLoggerFactory(_loggerFactory);
+
+    protected override void OnModelCreating(ModelBuilder builder)
     {
-        private readonly ILoggerFactory _loggerFactory;
+        base.OnModelCreating(builder);
 
-        public TvContext(DbContextOptions<TvContext> options, ILoggerFactory loggerFactory)
-            : base(options) =>
-            _loggerFactory = loggerFactory;
-
-        public DbSet<ConfigElement> ConfigElements { get; set; }
-        public DbSet<Channel> Channels { get; set; }
-        public DbSet<ChannelWatermark> ChannelWatermarks { get; set; }
-        public DbSet<MediaSource> MediaSources { get; set; }
-        public DbSet<LocalMediaSource> LocalMediaSources { get; set; }
-        public DbSet<PlexMediaSource> PlexMediaSources { get; set; }
-        public DbSet<JellyfinMediaSource> JellyfinMediaSources { get; set; }
-        public DbSet<EmbyMediaSource> EmbyMediaSources { get; set; }
-        public DbSet<Library> Libraries { get; set; }
-        public DbSet<LocalLibrary> LocalLibraries { get; set; }
-        public DbSet<LibraryPath> LibraryPaths { get; set; }
-        public DbSet<LibraryFolder> LibraryFolders { get; set; }
-        public DbSet<PlexLibrary> PlexLibraries { get; set; }
-        public DbSet<JellyfinLibrary> JellyfinLibraries { get; set; }
-        public DbSet<EmbyLibrary> EmbyLibraries { get; set; }
-        public DbSet<PlexPathReplacement> PlexPathReplacements { get; set; }
-        public DbSet<JellyfinPathReplacement> JellyfinPathReplacements { get; set; }
-        public DbSet<EmbyPathReplacement> EmbyPathReplacements { get; set; }
-        public DbSet<MediaItem> MediaItems { get; set; }
-        public DbSet<MediaVersion> MediaVersions { get; set; }
-        public DbSet<MediaFile> MediaFiles { get; set; }
-        public DbSet<MediaStream> MediaStreams { get; set; }
-        public DbSet<Movie> Movies { get; set; }
-        public DbSet<MovieMetadata> MovieMetadata { get; set; }
-        public DbSet<Artwork> Artwork { get; set; }
-        public DbSet<Artist> Artists { get; set; }
-        public DbSet<ArtistMetadata> ArtistMetadata { get; set; }
-        public DbSet<MusicVideo> MusicVideos { get; set; }
-        public DbSet<MusicVideoMetadata> MusicVideoMetadata { get; set; }
-        public DbSet<OtherVideo> OtherVideos { get; set; }
-        public DbSet<OtherVideoMetadata> OtherVideoMetadata { get; set; }
-        public DbSet<Song> Songs { get; set; }
-        public DbSet<SongMetadata> SongMetadata { get; set; }
-        public DbSet<Show> Shows { get; set; }
-        public DbSet<ShowMetadata> ShowMetadata { get; set; }
-        public DbSet<Season> Seasons { get; set; }
-        public DbSet<SeasonMetadata> SeasonMetadata { get; set; }
-        public DbSet<Episode> Episodes { get; set; }
-        public DbSet<EpisodeMetadata> EpisodeMetadata { get; set; }
-        public DbSet<PlexMovie> PlexMovies { get; set; }
-        public DbSet<PlexShow> PlexShows { get; set; }
-        public DbSet<PlexSeason> PlexSeasons { get; set; }
-        public DbSet<PlexEpisode> PlexEpisodes { get; set; }
-        public DbSet<JellyfinMovie> JellyfinMovies { get; set; }
-        public DbSet<JellyfinShow> JellyfinShows { get; set; }
-        public DbSet<JellyfinSeason> JellyfinSeasons { get; set; }
-        public DbSet<JellyfinEpisode> JellyfinEpisodes { get; set; }
-        public DbSet<EmbyMovie> EmbyMovies { get; set; }
-        public DbSet<EmbyShow> EmbyShows { get; set; }
-        public DbSet<EmbySeason> EmbySeasons { get; set; }
-        public DbSet<EmbyEpisode> EmbyEpisodes { get; set; }
-        public DbSet<Collection> Collections { get; set; }
-        public DbSet<CollectionItem> CollectionItems { get; set; }
-        public DbSet<MultiCollection> MultiCollections { get; set; }
-        public DbSet<SmartCollection> SmartCollections { get; set; }
-        public DbSet<ProgramSchedule> ProgramSchedules { get; set; }
-        public DbSet<ProgramScheduleItem> ProgramScheduleItems { get; set; }
-        public DbSet<Playout> Playouts { get; set; }
-        public DbSet<PlayoutItem> PlayoutItems { get; set; }
-        public DbSet<PlayoutProgramScheduleAnchor> PlayoutProgramScheduleItemAnchors { get; set; }
-        public DbSet<FFmpegProfile> FFmpegProfiles { get; set; }
-        public DbSet<Resolution> Resolutions { get; set; }
-        public DbSet<LanguageCode> LanguageCodes { get; set; }
-        public DbSet<TraktList> TraktLists { get; set; }
-        public DbSet<FillerPreset> FillerPresets { get; set; }
-
-        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) =>
-            optionsBuilder.UseLoggerFactory(_loggerFactory);
-
-        protected override void OnModelCreating(ModelBuilder builder)
-        {
-            base.OnModelCreating(builder);
-
-            builder.ApplyConfigurationsFromAssembly(typeof(TvContext).Assembly);
-        }
+        builder.ApplyConfigurationsFromAssembly(typeof(TvContext).Assembly);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/EmbyApiClient.cs b/ErsatzTV.Infrastructure/Emby/EmbyApiClient.cs
index 329975ca1..f4cfbc34b 100644
--- a/ErsatzTV.Infrastructure/Emby/EmbyApiClient.cs
+++ b/ErsatzTV.Infrastructure/Emby/EmbyApiClient.cs
@@ -1,265 +1,435 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Infrastructure.Emby.Models;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Refit;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Emby
+namespace ErsatzTV.Infrastructure.Emby;
+
+public class EmbyApiClient : IEmbyApiClient
 {
-    public class EmbyApiClient : IEmbyApiClient
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
+    private readonly ILogger<EmbyApiClient> _logger;
+
+    public EmbyApiClient(IFallbackMetadataProvider fallbackMetadataProvider, ILogger<EmbyApiClient> logger)
     {
-        private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
-        private readonly ILogger<EmbyApiClient> _logger;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
+        _logger = logger;
+    }
 
-        public EmbyApiClient(IFallbackMetadataProvider fallbackMetadataProvider, ILogger<EmbyApiClient> logger)
+    public async Task<Either<BaseError, EmbyServerInformation>> GetServerInformation(
+        string address,
+        string apiKey)
+    {
+        try
         {
-            _fallbackMetadataProvider = fallbackMetadataProvider;
-            _logger = logger;
+            IEmbyApi service = RestService.For<IEmbyApi>(address);
+            var cts = new CancellationTokenSource();
+            cts.CancelAfter(TimeSpan.FromSeconds(5));
+            return await service.GetSystemInformation(apiKey, cts.Token)
+                .Map(response => new EmbyServerInformation(response.ServerName, response.OperatingSystem));
         }
-
-        public async Task<Either<BaseError, EmbyServerInformation>> GetServerInformation(
-            string address,
-            string apiKey)
+        catch (OperationCanceledException ex)
         {
-            try
-            {
-                IEmbyApi service = RestService.For<IEmbyApi>(address);
-                var cts = new CancellationTokenSource();
-                cts.CancelAfter(TimeSpan.FromSeconds(5));
-                return await service.GetSystemInformation(apiKey, cts.Token)
-                    .Map(response => new EmbyServerInformation(response.ServerName, response.OperatingSystem));
-            }
-            catch (OperationCanceledException ex)
-            {
-                _logger.LogError(ex, "Timeout getting emby server name");
-                return BaseError.New("Emby did not respond in time");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting emby server name");
-                return BaseError.New(ex.Message);
-            }
+            _logger.LogError(ex, "Timeout getting emby server name");
+            return BaseError.New("Emby did not respond in time");
         }
-
-        public async Task<Either<BaseError, List<EmbyLibrary>>> GetLibraries(string address, string apiKey)
+        catch (Exception ex)
         {
-            try
-            {
-                IEmbyApi service = RestService.For<IEmbyApi>(address);
-                List<EmbyLibraryResponse> libraries = await service.GetLibraries(apiKey);
-                return libraries
-                    .Map(Project)
-                    .Somes()
-                    .ToList();
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting emby libraries");
-                return BaseError.New(ex.Message);
-            }
+            _logger.LogError(ex, "Error getting emby server name");
+            return BaseError.New(ex.Message);
         }
+    }
 
-        public async Task<Either<BaseError, List<EmbyMovie>>> GetMovieLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string libraryId)
+    public async Task<Either<BaseError, List<EmbyLibrary>>> GetLibraries(string address, string apiKey)
+    {
+        try
         {
-            try
-            {
-                IEmbyApi service = RestService.For<IEmbyApi>(address);
-                EmbyLibraryItemsResponse items = await service.GetMovieLibraryItems(apiKey, libraryId);
-                return items.Items
-                    .Map(ProjectToMovie)
-                    .Somes()
-                    .ToList();
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting emby movie library items");
-                return BaseError.New(ex.Message);
-            }
+            IEmbyApi service = RestService.For<IEmbyApi>(address);
+            List<EmbyLibraryResponse> libraries = await service.GetLibraries(apiKey);
+            return libraries
+                .Map(Project)
+                .Somes()
+                .ToList();
         }
-
-        public async Task<Either<BaseError, List<EmbyShow>>> GetShowLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string libraryId)
+        catch (Exception ex)
         {
-            try
-            {
-                IEmbyApi service = RestService.For<IEmbyApi>(address);
-                EmbyLibraryItemsResponse items = await service.GetShowLibraryItems(apiKey, libraryId);
-                return items.Items
-                    .Map(ProjectToShow)
-                    .Somes()
-                    .ToList();
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting emby show library items");
-                return BaseError.New(ex.Message);
-            }
+            _logger.LogError(ex, "Error getting emby libraries");
+            return BaseError.New(ex.Message);
         }
+    }
 
-        public async Task<Either<BaseError, List<EmbySeason>>> GetSeasonLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string showId)
+    public async Task<Either<BaseError, List<EmbyMovie>>> GetMovieLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string libraryId)
+    {
+        try
         {
-            try
-            {
-                IEmbyApi service = RestService.For<IEmbyApi>(address);
-                EmbyLibraryItemsResponse items = await service.GetSeasonLibraryItems(apiKey, showId);
-                return items.Items
-                    .Map(ProjectToSeason)
-                    .Somes()
-                    .ToList();
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting emby show library items");
-                return BaseError.New(ex.Message);
-            }
+            IEmbyApi service = RestService.For<IEmbyApi>(address);
+            EmbyLibraryItemsResponse items = await service.GetMovieLibraryItems(apiKey, libraryId);
+            return items.Items
+                .Map(ProjectToMovie)
+                .Somes()
+                .ToList();
         }
-
-        public async Task<Either<BaseError, List<EmbyEpisode>>> GetEpisodeLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string seasonId)
+        catch (Exception ex)
         {
-            try
-            {
-                IEmbyApi service = RestService.For<IEmbyApi>(address);
-                EmbyLibraryItemsResponse items = await service.GetEpisodeLibraryItems(apiKey, seasonId);
-                return items.Items
-                    .Map(ProjectToEpisode)
-                    .Somes()
-                    .ToList();
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting emby episode library items");
-                return BaseError.New(ex.Message);
-            }
+            _logger.LogError(ex, "Error getting emby movie library items");
+            return BaseError.New(ex.Message);
         }
+    }
 
-        private static Option<EmbyLibrary> Project(EmbyLibraryResponse response) =>
-            response.CollectionType?.ToLowerInvariant() switch
-            {
-                "tvshows" => new EmbyLibrary
-                {
-                    ItemId = response.ItemId,
-                    Name = response.Name,
-                    MediaKind = LibraryMediaKind.Shows,
-                    ShouldSyncItems = false,
-                    Paths = new List<LibraryPath> { new() { Path = $"emby://{response.ItemId}" } }
-                },
-                "movies" => new EmbyLibrary
-                {
-                    ItemId = response.ItemId,
-                    Name = response.Name,
-                    MediaKind = LibraryMediaKind.Movies,
-                    ShouldSyncItems = false,
-                    Paths = new List<LibraryPath> { new() { Path = $"emby://{response.ItemId}" } }
-                },
-                // TODO: ??? for music libraries
-                _ => None
-            };
-
-        private Option<EmbyMovie> ProjectToMovie(EmbyLibraryItemResponse item)
+    public async Task<Either<BaseError, List<EmbyShow>>> GetShowLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string libraryId)
+    {
+        try
         {
-            try
+            IEmbyApi service = RestService.For<IEmbyApi>(address);
+            EmbyLibraryItemsResponse items = await service.GetShowLibraryItems(apiKey, libraryId);
+            return items.Items
+                .Map(ProjectToShow)
+                .Somes()
+                .ToList();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting emby show library items");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    public async Task<Either<BaseError, List<EmbySeason>>> GetSeasonLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string showId)
+    {
+        try
+        {
+            IEmbyApi service = RestService.For<IEmbyApi>(address);
+            EmbyLibraryItemsResponse items = await service.GetSeasonLibraryItems(apiKey, showId);
+            return items.Items
+                .Map(ProjectToSeason)
+                .Somes()
+                .ToList();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting emby show library items");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    public async Task<Either<BaseError, List<EmbyEpisode>>> GetEpisodeLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string seasonId)
+    {
+        try
+        {
+            IEmbyApi service = RestService.For<IEmbyApi>(address);
+            EmbyLibraryItemsResponse items = await service.GetEpisodeLibraryItems(apiKey, seasonId);
+            return items.Items
+                .Map(ProjectToEpisode)
+                .Somes()
+                .ToList();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting emby episode library items");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    private static Option<EmbyLibrary> Project(EmbyLibraryResponse response) =>
+        response.CollectionType?.ToLowerInvariant() switch
+        {
+            "tvshows" => new EmbyLibrary
             {
-                if (item.MediaSources.Any(ms => ms.Protocol != "File"))
-                {
-                    return None;
-                }
-
-                var version = new MediaVersion
-                {
-                    Name = "Main",
-                    Duration = TimeSpan.FromTicks(item.RunTimeTicks),
-                    DateAdded = item.DateCreated.UtcDateTime,
-                    MediaFiles = new List<MediaFile>
-                    {
-                        new()
-                        {
-                            Path = item.Path
-                        }
-                    },
-                    Streams = new List<MediaStream>()
-                };
-
-                MovieMetadata metadata = ProjectToMovieMetadata(item);
-
-                var movie = new EmbyMovie
-                {
-                    ItemId = item.Id,
-                    Etag = item.Etag,
-                    MediaVersions = new List<MediaVersion> { version },
-                    MovieMetadata = new List<MovieMetadata> { metadata },
-                    TraktListItems = new List<TraktListItem>()
-                };
-
-                return movie;
-            }
-            catch (Exception ex)
+                ItemId = response.ItemId,
+                Name = response.Name,
+                MediaKind = LibraryMediaKind.Shows,
+                ShouldSyncItems = false,
+                Paths = new List<LibraryPath> { new() { Path = $"emby://{response.ItemId}" } }
+            },
+            "movies" => new EmbyLibrary
+            {
+                ItemId = response.ItemId,
+                Name = response.Name,
+                MediaKind = LibraryMediaKind.Movies,
+                ShouldSyncItems = false,
+                Paths = new List<LibraryPath> { new() { Path = $"emby://{response.ItemId}" } }
+            },
+            // TODO: ??? for music libraries
+            _ => None
+        };
+
+    private Option<EmbyMovie> ProjectToMovie(EmbyLibraryItemResponse item)
+    {
+        try
+        {
+            if (item.MediaSources.Any(ms => ms.Protocol != "File"))
             {
-                _logger.LogWarning(ex, "Error projecting Emby movie");
                 return None;
             }
+
+            var version = new MediaVersion
+            {
+                Name = "Main",
+                Duration = TimeSpan.FromTicks(item.RunTimeTicks),
+                DateAdded = item.DateCreated.UtcDateTime,
+                MediaFiles = new List<MediaFile>
+                {
+                    new()
+                    {
+                        Path = item.Path
+                    }
+                },
+                Streams = new List<MediaStream>()
+            };
+
+            MovieMetadata metadata = ProjectToMovieMetadata(item);
+
+            var movie = new EmbyMovie
+            {
+                ItemId = item.Id,
+                Etag = item.Etag,
+                MediaVersions = new List<MediaVersion> { version },
+                MovieMetadata = new List<MovieMetadata> { metadata },
+                TraktListItems = new List<TraktListItem>()
+            };
+
+            return movie;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error projecting Emby movie");
+            return None;
+        }
+    }
+
+    private MovieMetadata ProjectToMovieMetadata(EmbyLibraryItemResponse item)
+    {
+        DateTime dateAdded = item.DateCreated.UtcDateTime;
+        // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
+
+        var metadata = new MovieMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = item.Name,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
+            Plot = item.Overview,
+            Year = item.ProductionYear,
+            Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
+            DateAdded = dateAdded,
+            ContentRating = item.OfficialRating,
+            Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
+            Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
+            Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
+            Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
+            Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
+            Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList(),
+            Artwork = new List<Artwork>(),
+            Guids = GuidsFromProviderIds(item.ProviderIds)
+        };
+
+        // set order on actors
+        for (var i = 0; i < metadata.Actors.Count; i++)
+        {
+            metadata.Actors[i].Order = i;
         }
 
-        private MovieMetadata ProjectToMovieMetadata(EmbyLibraryItemResponse item)
+        if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
+        {
+            metadata.ReleaseDate = releaseDate;
+        }
+
+        if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
+        {
+            var poster = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Poster,
+                Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(poster);
+        }
+
+        if (item.BackdropImageTags.Any())
+        {
+            var fanArt = new Artwork
+            {
+                ArtworkKind = ArtworkKind.FanArt,
+                Path = $"emby://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(fanArt);
+        }
+
+        return metadata;
+    }
+
+    private Option<Actor> ProjectToActor(EmbyPersonResponse person, DateTime dateAdded)
+    {
+        if (person.Type?.ToLowerInvariant() != "actor")
+        {
+            return None;
+        }
+
+        var actor = new Actor { Name = person.Name, Role = person.Role };
+        if (!string.IsNullOrWhiteSpace(person.Id) && !string.IsNullOrWhiteSpace(person.PrimaryImageTag))
+        {
+            actor.Artwork = new Artwork
+            {
+                Path = $"emby://Items/{person.Id}/Images/Primary?tag={person.PrimaryImageTag}",
+                ArtworkKind = ArtworkKind.Thumbnail,
+                DateAdded = dateAdded
+            };
+        }
+
+        return actor;
+    }
+
+    private static Option<Director> ProjectToDirector(EmbyPersonResponse person)
+    {
+        if (person.Type?.ToLowerInvariant() != "director")
+        {
+            return None;
+        }
+
+        return new Director { Name = person.Name };
+    }
+
+    private static Option<Writer> ProjectToWriter(EmbyPersonResponse person)
+    {
+        if (person.Type?.ToLowerInvariant() != "writer")
+        {
+            return None;
+        }
+
+        return new Writer { Name = person.Name };
+    }
+
+    private Option<EmbyShow> ProjectToShow(EmbyLibraryItemResponse item)
+    {
+        try
+        {
+            ShowMetadata metadata = ProjectToShowMetadata(item);
+
+            var show = new EmbyShow
+            {
+                ItemId = item.Id,
+                Etag = item.Etag,
+                ShowMetadata = new List<ShowMetadata> { metadata },
+                TraktListItems = new List<TraktListItem>()
+            };
+
+            return show;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error projecting Emby show");
+            return None;
+        }
+    }
+
+    private ShowMetadata ProjectToShowMetadata(EmbyLibraryItemResponse item)
+    {
+        DateTime dateAdded = item.DateCreated.UtcDateTime;
+        // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
+
+        var metadata = new ShowMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = item.Name,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
+            Plot = item.Overview,
+            Year = item.ProductionYear,
+            Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
+            DateAdded = dateAdded,
+            ContentRating = item.OfficialRating,
+            Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
+            Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
+            Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
+            Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
+            Artwork = new List<Artwork>(),
+            Guids = GuidsFromProviderIds(item.ProviderIds)
+        };
+
+        // set order on actors
+        for (var i = 0; i < metadata.Actors.Count; i++)
+        {
+            metadata.Actors[i].Order = i;
+        }
+
+        if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
+        {
+            metadata.ReleaseDate = releaseDate;
+        }
+
+        if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
+        {
+            var poster = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Poster,
+                Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(poster);
+        }
+
+        if (!string.IsNullOrWhiteSpace(item.ImageTags.Thumb))
+        {
+            var thumb = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Thumbnail,
+                Path = $"emby://Items/{item.Id}/Images/Thumb?tag={item.ImageTags.Thumb}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(thumb);
+        }
+
+        if (item.BackdropImageTags.Any())
+        {
+            var fanArt = new Artwork
+            {
+                ArtworkKind = ArtworkKind.FanArt,
+                Path = $"emby://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(fanArt);
+        }
+
+        return metadata;
+    }
+
+    private Option<EmbySeason> ProjectToSeason(EmbyLibraryItemResponse item)
+    {
+        try
         {
             DateTime dateAdded = item.DateCreated.UtcDateTime;
-            // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
+            // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
 
-            var metadata = new MovieMetadata
+            var metadata = new SeasonMetadata
             {
                 MetadataKind = MetadataKind.External,
                 Title = item.Name,
                 SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
-                Plot = item.Overview,
                 Year = item.ProductionYear,
-                Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
                 DateAdded = dateAdded,
-                ContentRating = item.OfficialRating,
-                Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
-                Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
-                Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
-                Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
-                Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
-                Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList(),
                 Artwork = new List<Artwork>(),
                 Guids = GuidsFromProviderIds(item.ProviderIds)
             };
 
-            // set order on actors
-            for (var i = 0; i < metadata.Actors.Count; i++)
-            {
-                metadata.Actors[i].Order = i;
-            }
-
-            if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
             if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
             {
                 var poster = new Artwork
@@ -282,319 +452,141 @@ namespace ErsatzTV.Infrastructure.Emby
                 metadata.Artwork.Add(fanArt);
             }
 
-            return metadata;
-        }
-
-        private Option<Actor> ProjectToActor(EmbyPersonResponse person, DateTime dateAdded)
-        {
-            if (person.Type?.ToLowerInvariant() != "actor")
+            var season = new EmbySeason
             {
-                return None;
-            }
-
-            var actor = new Actor { Name = person.Name, Role = person.Role };
-            if (!string.IsNullOrWhiteSpace(person.Id) && !string.IsNullOrWhiteSpace(person.PrimaryImageTag))
-            {
-                actor.Artwork = new Artwork
-                {
-                    Path = $"emby://Items/{person.Id}/Images/Primary?tag={person.PrimaryImageTag}",
-                    ArtworkKind = ArtworkKind.Thumbnail,
-                    DateAdded = dateAdded
-                };
-            }
-
-            return actor;
-        }
-
-        private static Option<Director> ProjectToDirector(EmbyPersonResponse person)
-        {
-            if (person.Type?.ToLowerInvariant() != "director")
-            {
-                return None;
-            }
-
-            return new Director { Name = person.Name };
-        }
-
-        private static Option<Writer> ProjectToWriter(EmbyPersonResponse person)
-        {
-            if (person.Type?.ToLowerInvariant() != "writer")
-            {
-                return None;
-            }
-
-            return new Writer { Name = person.Name };
-        }
-
-        private Option<EmbyShow> ProjectToShow(EmbyLibraryItemResponse item)
-        {
-            try
-            {
-                ShowMetadata metadata = ProjectToShowMetadata(item);
-
-                var show = new EmbyShow
-                {
-                    ItemId = item.Id,
-                    Etag = item.Etag,
-                    ShowMetadata = new List<ShowMetadata> { metadata },
-                    TraktListItems = new List<TraktListItem>()
-                };
-
-                return show;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error projecting Emby show");
-                return None;
-            }
-        }
-
-        private ShowMetadata ProjectToShowMetadata(EmbyLibraryItemResponse item)
-        {
-            DateTime dateAdded = item.DateCreated.UtcDateTime;
-            // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
-
-            var metadata = new ShowMetadata
-            {
-                MetadataKind = MetadataKind.External,
-                Title = item.Name,
-                SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
-                Plot = item.Overview,
-                Year = item.ProductionYear,
-                Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
-                DateAdded = dateAdded,
-                ContentRating = item.OfficialRating,
-                Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
-                Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
-                Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
-                Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
-                Artwork = new List<Artwork>(),
-                Guids = GuidsFromProviderIds(item.ProviderIds)
-            };
-
-            // set order on actors
-            for (var i = 0; i < metadata.Actors.Count; i++)
-            {
-                metadata.Actors[i].Order = i;
-            }
-
-            if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
-            if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
-            {
-                var poster = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Poster,
-                    Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
-                    DateAdded = dateAdded
-                };
-                metadata.Artwork.Add(poster);
-            }
-
-            if (!string.IsNullOrWhiteSpace(item.ImageTags.Thumb))
-            {
-                var thumb = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Thumbnail,
-                    Path = $"emby://Items/{item.Id}/Images/Thumb?tag={item.ImageTags.Thumb}",
-                    DateAdded = dateAdded
-                };
-                metadata.Artwork.Add(thumb);
-            }
-
-            if (item.BackdropImageTags.Any())
-            {
-                var fanArt = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.FanArt,
-                    Path = $"emby://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
-                    DateAdded = dateAdded
-                };
-                metadata.Artwork.Add(fanArt);
-            }
-
-            return metadata;
-        }
-
-        private Option<EmbySeason> ProjectToSeason(EmbyLibraryItemResponse item)
-        {
-            try
-            {
-                DateTime dateAdded = item.DateCreated.UtcDateTime;
-                // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
-
-                var metadata = new SeasonMetadata
-                {
-                    MetadataKind = MetadataKind.External,
-                    Title = item.Name,
-                    SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
-                    Year = item.ProductionYear,
-                    DateAdded = dateAdded,
-                    Artwork = new List<Artwork>(),
-                    Guids = GuidsFromProviderIds(item.ProviderIds)
-                };
-
-                if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
-                {
-                    var poster = new Artwork
-                    {
-                        ArtworkKind = ArtworkKind.Poster,
-                        Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
-                        DateAdded = dateAdded
-                    };
-                    metadata.Artwork.Add(poster);
-                }
-
-                if (item.BackdropImageTags.Any())
-                {
-                    var fanArt = new Artwork
-                    {
-                        ArtworkKind = ArtworkKind.FanArt,
-                        Path = $"emby://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
-                        DateAdded = dateAdded
-                    };
-                    metadata.Artwork.Add(fanArt);
-                }
-
-                var season = new EmbySeason
-                {
-                    ItemId = item.Id,
-                    Etag = item.Etag,
-                    SeasonMetadata = new List<SeasonMetadata> { metadata },
-                    TraktListItems = new List<TraktListItem>()
-                };
-
-                if (item.IndexNumber.HasValue)
-                {
-                    season.SeasonNumber = item.IndexNumber.Value;
-                }
-
-                return season;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error projecting Emby show");
-                return None;
-            }
-        }
-
-        private Option<EmbyEpisode> ProjectToEpisode(EmbyLibraryItemResponse item)
-        {
-            try
-            {
-                if (item.LocationType == "Virtual")
-                {
-                    return None;
-                }
-
-                var version = new MediaVersion
-                {
-                    Name = "Main",
-                    Duration = TimeSpan.FromTicks(item.RunTimeTicks),
-                    DateAdded = item.DateCreated.UtcDateTime,
-                    MediaFiles = new List<MediaFile>
-                    {
-                        new()
-                        {
-                            Path = item.Path
-                        }
-                    },
-                    Streams = new List<MediaStream>()
-                };
-
-                EpisodeMetadata metadata = ProjectToEpisodeMetadata(item);
-
-                var episode = new EmbyEpisode
-                {
-                    ItemId = item.Id,
-                    Etag = item.Etag,
-                    MediaVersions = new List<MediaVersion> { version },
-                    EpisodeMetadata = new List<EpisodeMetadata> { metadata },
-                    TraktListItems = new List<TraktListItem>()
-                };
-
-                return episode;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error projecting Emby movie");
-                return None;
-            }
-        }
-
-        private EpisodeMetadata ProjectToEpisodeMetadata(EmbyLibraryItemResponse item)
-        {
-            DateTime dateAdded = item.DateCreated.UtcDateTime;
-            // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
-
-            var metadata = new EpisodeMetadata
-            {
-                MetadataKind = MetadataKind.External,
-                Title = item.Name,
-                SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
-                Plot = item.Overview,
-                Year = item.ProductionYear,
-                DateAdded = dateAdded,
-                Genres = new List<Genre>(),
-                Tags = new List<Tag>(),
-                Studios = new List<Studio>(),
-                Actors = new List<Actor>(),
-                Artwork = new List<Artwork>(),
-                Guids = GuidsFromProviderIds(item.ProviderIds),
-                Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
-                Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList()
+                ItemId = item.Id,
+                Etag = item.Etag,
+                SeasonMetadata = new List<SeasonMetadata> { metadata },
+                TraktListItems = new List<TraktListItem>()
             };
 
             if (item.IndexNumber.HasValue)
             {
-                metadata.EpisodeNumber = item.IndexNumber.Value;
+                season.SeasonNumber = item.IndexNumber.Value;
             }
 
-            if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
-            if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
-            {
-                var thumbnail = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Thumbnail,
-                    Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
-                    DateAdded = dateAdded
-                };
-                metadata.Artwork.Add(thumbnail);
-            }
-
-            return metadata;
+            return season;
         }
-
-        private List<MetadataGuid> GuidsFromProviderIds(EmbyProviderIdsResponse providerIds)
+        catch (Exception ex)
         {
-            var result = new List<MetadataGuid>();
-
-            if (providerIds != null)
-            {
-                if (!string.IsNullOrWhiteSpace(providerIds.Imdb))
-                {
-                    result.Add(new MetadataGuid { Guid = $"imdb://{providerIds.Imdb}" });
-                }
-
-                if (!string.IsNullOrWhiteSpace(providerIds.Tmdb))
-                {
-                    result.Add(new MetadataGuid { Guid = $"tmdb://{providerIds.Tmdb}" });
-                }
-
-                if (!string.IsNullOrWhiteSpace(providerIds.Tvdb))
-                {
-                    result.Add(new MetadataGuid { Guid = $"tvdb://{providerIds.Tvdb}" });
-                }
-            }
-
-            return result;
+            _logger.LogWarning(ex, "Error projecting Emby show");
+            return None;
         }
     }
-}
+
+    private Option<EmbyEpisode> ProjectToEpisode(EmbyLibraryItemResponse item)
+    {
+        try
+        {
+            if (item.LocationType == "Virtual")
+            {
+                return None;
+            }
+
+            var version = new MediaVersion
+            {
+                Name = "Main",
+                Duration = TimeSpan.FromTicks(item.RunTimeTicks),
+                DateAdded = item.DateCreated.UtcDateTime,
+                MediaFiles = new List<MediaFile>
+                {
+                    new()
+                    {
+                        Path = item.Path
+                    }
+                },
+                Streams = new List<MediaStream>()
+            };
+
+            EpisodeMetadata metadata = ProjectToEpisodeMetadata(item);
+
+            var episode = new EmbyEpisode
+            {
+                ItemId = item.Id,
+                Etag = item.Etag,
+                MediaVersions = new List<MediaVersion> { version },
+                EpisodeMetadata = new List<EpisodeMetadata> { metadata },
+                TraktListItems = new List<TraktListItem>()
+            };
+
+            return episode;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error projecting Emby movie");
+            return None;
+        }
+    }
+
+    private EpisodeMetadata ProjectToEpisodeMetadata(EmbyLibraryItemResponse item)
+    {
+        DateTime dateAdded = item.DateCreated.UtcDateTime;
+        // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
+
+        var metadata = new EpisodeMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = item.Name,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
+            Plot = item.Overview,
+            Year = item.ProductionYear,
+            DateAdded = dateAdded,
+            Genres = new List<Genre>(),
+            Tags = new List<Tag>(),
+            Studios = new List<Studio>(),
+            Actors = new List<Actor>(),
+            Artwork = new List<Artwork>(),
+            Guids = GuidsFromProviderIds(item.ProviderIds),
+            Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
+            Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList()
+        };
+
+        if (item.IndexNumber.HasValue)
+        {
+            metadata.EpisodeNumber = item.IndexNumber.Value;
+        }
+
+        if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
+        {
+            metadata.ReleaseDate = releaseDate;
+        }
+
+        if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
+        {
+            var thumbnail = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Thumbnail,
+                Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(thumbnail);
+        }
+
+        return metadata;
+    }
+
+    private List<MetadataGuid> GuidsFromProviderIds(EmbyProviderIdsResponse providerIds)
+    {
+        var result = new List<MetadataGuid>();
+
+        if (providerIds != null)
+        {
+            if (!string.IsNullOrWhiteSpace(providerIds.Imdb))
+            {
+                result.Add(new MetadataGuid { Guid = $"imdb://{providerIds.Imdb}" });
+            }
+
+            if (!string.IsNullOrWhiteSpace(providerIds.Tmdb))
+            {
+                result.Add(new MetadataGuid { Guid = $"tmdb://{providerIds.Tmdb}" });
+            }
+
+            if (!string.IsNullOrWhiteSpace(providerIds.Tvdb))
+            {
+                result.Add(new MetadataGuid { Guid = $"tvdb://{providerIds.Tvdb}" });
+            }
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/EmbySecretStore.cs b/ErsatzTV.Infrastructure/Emby/EmbySecretStore.cs
index d3ed7da65..1e0248c6d 100644
--- a/ErsatzTV.Infrastructure/Emby/EmbySecretStore.cs
+++ b/ErsatzTV.Infrastructure/Emby/EmbySecretStore.cs
@@ -1,26 +1,21 @@
-using System.IO;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Interfaces.Emby;
-using LanguageExt;
 using Newtonsoft.Json;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Emby
+namespace ErsatzTV.Infrastructure.Emby;
+
+public class EmbySecretStore : IEmbySecretStore
 {
-    public class EmbySecretStore : IEmbySecretStore
-    {
-        public Task<Unit> DeleteAll() => SaveSecrets(new EmbySecrets());
+    public Task<Unit> DeleteAll() => SaveSecrets(new EmbySecrets());
 
-        public Task<EmbySecrets> ReadSecrets() =>
-            File.ReadAllTextAsync(FileSystemLayout.EmbySecretsPath)
-                .Map(JsonConvert.DeserializeObject<EmbySecrets>)
-                .Map(s => Optional(s).IfNone(new EmbySecrets()));
+    public Task<EmbySecrets> ReadSecrets() =>
+        File.ReadAllTextAsync(FileSystemLayout.EmbySecretsPath)
+            .Map(JsonConvert.DeserializeObject<EmbySecrets>)
+            .Map(s => Optional(s).IfNone(new EmbySecrets()));
 
-        public Task<Unit> SaveSecrets(EmbySecrets embySecrets) =>
-            Some(JsonConvert.SerializeObject(embySecrets)).Match(
-                s => File.WriteAllTextAsync(FileSystemLayout.EmbySecretsPath, s).ToUnit(),
-                Task.FromResult(Unit.Default));
-    }
-}
+    public Task<Unit> SaveSecrets(EmbySecrets embySecrets) =>
+        Some(JsonConvert.SerializeObject(embySecrets)).Match(
+            s => File.WriteAllTextAsync(FileSystemLayout.EmbySecretsPath, s).ToUnit(),
+            Task.FromResult(Unit.Default));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/IEmbyApi.cs b/ErsatzTV.Infrastructure/Emby/IEmbyApi.cs
index 2e995f587..9f25fe794 100644
--- a/ErsatzTV.Infrastructure/Emby/IEmbyApi.cs
+++ b/ErsatzTV.Infrastructure/Emby/IEmbyApi.cs
@@ -1,82 +1,78 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Emby.Models;
+using ErsatzTV.Infrastructure.Emby.Models;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.Emby
+namespace ErsatzTV.Infrastructure.Emby;
+
+[Headers("Accept: application/json")]
+public interface IEmbyApi
 {
-    [Headers("Accept: application/json")]
-    public interface IEmbyApi
-    {
-        [Get("/System/Info")]
-        public Task<EmbySystemInformationResponse> GetSystemInformation(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            CancellationToken cancellationToken);
+    [Get("/System/Info")]
+    public Task<EmbySystemInformationResponse> GetSystemInformation(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        CancellationToken cancellationToken);
 
-        [Get("/Library/VirtualFolders")]
-        public Task<List<EmbyLibraryResponse>> GetLibraries(
-            [Header("X-Emby-Token")]
-            string apiKey);
+    [Get("/Library/VirtualFolders")]
+    public Task<List<EmbyLibraryResponse>> GetLibraries(
+        [Header("X-Emby-Token")]
+        string apiKey);
 
-        [Get("/Items")]
-        public Task<EmbyLibraryItemsResponse> GetMovieLibraryItems(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            [Query]
-            string parentId,
-            [Query]
-            string fields =
-                "Path,Genres,Tags,DateCreated,Etag,Overview,Taglines,Studios,People,ProductionYear,PremiereDate,MediaSources,OfficialRating,ProviderIds",
-            [Query]
-            string includeItemTypes = "Movie",
-            [Query]
-            bool recursive = true);
+    [Get("/Items")]
+    public Task<EmbyLibraryItemsResponse> GetMovieLibraryItems(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string parentId,
+        [Query]
+        string fields =
+            "Path,Genres,Tags,DateCreated,Etag,Overview,Taglines,Studios,People,ProductionYear,PremiereDate,MediaSources,OfficialRating,ProviderIds",
+        [Query]
+        string includeItemTypes = "Movie",
+        [Query]
+        bool recursive = true);
 
-        [Get("/Items")]
-        public Task<EmbyLibraryItemsResponse> GetShowLibraryItems(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            [Query]
-            string parentId,
-            [Query]
-            string fields =
-                "Path,Genres,Tags,DateCreated,Etag,Overview,Taglines,Studios,People,ProductionYear,PremiereDate,MediaSources,OfficialRating,ProviderIds",
-            [Query]
-            string includeItemTypes = "Series",
-            [Query]
-            bool recursive = true);
+    [Get("/Items")]
+    public Task<EmbyLibraryItemsResponse> GetShowLibraryItems(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string parentId,
+        [Query]
+        string fields =
+            "Path,Genres,Tags,DateCreated,Etag,Overview,Taglines,Studios,People,ProductionYear,PremiereDate,MediaSources,OfficialRating,ProviderIds",
+        [Query]
+        string includeItemTypes = "Series",
+        [Query]
+        bool recursive = true);
 
-        [Get("/Items")]
-        public Task<EmbyLibraryItemsResponse> GetSeasonLibraryItems(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            [Query]
-            string parentId,
-            [Query]
-            string fields = "Path,DateCreated,Etag,Taglines,ProviderIds",
-            [Query]
-            string includeItemTypes = "Season",
-            [Query]
-            string excludeLocationTypes = "Virtual",
-            [Query]
-            bool recursive = true);
+    [Get("/Items")]
+    public Task<EmbyLibraryItemsResponse> GetSeasonLibraryItems(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string parentId,
+        [Query]
+        string fields = "Path,DateCreated,Etag,Taglines,ProviderIds",
+        [Query]
+        string includeItemTypes = "Season",
+        [Query]
+        string excludeLocationTypes = "Virtual",
+        [Query]
+        bool recursive = true);
 
-        [Get("/Items")]
-        public Task<EmbyLibraryItemsResponse> GetEpisodeLibraryItems(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            [Query]
-            string parentId,
-            [Query]
-            string fields =
-                "Path,DateCreated,Etag,Overview,ProductionYear,PremiereDate,MediaSources,LocationType,ProviderIds,People",
-            [Query]
-            string includeItemTypes = "Episode",
-            [Query]
-            string excludeLocationTypes = "Virtual",
-            [Query]
-            bool recursive = true);
-    }
-}
+    [Get("/Items")]
+    public Task<EmbyLibraryItemsResponse> GetEpisodeLibraryItems(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string parentId,
+        [Query]
+        string fields =
+            "Path,DateCreated,Etag,Overview,ProductionYear,PremiereDate,MediaSources,LocationType,ProviderIds,People",
+        [Query]
+        string includeItemTypes = "Episode",
+        [Query]
+        string excludeLocationTypes = "Virtual",
+        [Query]
+        bool recursive = true);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyImageTagsResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyImageTagsResponse.cs
index ec28f2e2a..2b22ed6bc 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyImageTagsResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyImageTagsResponse.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Emby.Models
+namespace ErsatzTV.Infrastructure.Emby.Models;
+
+public class EmbyImageTagsResponse
 {
-    public class EmbyImageTagsResponse
-    {
-        public string Primary { get; set; }
-        public string Thumb { get; set; }
-    }
-}
+    public string Primary { get; set; }
+    public string Thumb { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemResponse.cs
index 32ecd45e1..de0aff4de 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemResponse.cs
@@ -1,31 +1,27 @@
-using System;
-using System.Collections.Generic;
+namespace ErsatzTV.Infrastructure.Emby.Models;
 
-namespace ErsatzTV.Infrastructure.Emby.Models
+public class EmbyLibraryItemResponse
 {
-    public class EmbyLibraryItemResponse
-    {
-        public string Name { get; set; }
-        public string Id { get; set; }
-        public string Etag { get; set; }
-        public string Path { get; set; }
-        public string OfficialRating { get; set; }
-        public DateTimeOffset DateCreated { get; set; }
-        public long RunTimeTicks { get; set; }
-        public List<string> Genres { get; set; }
-        public List<string> Tags { get; set; }
-        public int ProductionYear { get; set; }
-        public EmbyProviderIdsResponse ProviderIds { get; set; }
-        public string PremiereDate { get; set; }
-        public List<EmbyMediaStreamResponse> MediaStreams { get; set; }
-        public List<EmbyMediaSourceResponse> MediaSources { get; set; }
-        public string LocationType { get; set; }
-        public string Overview { get; set; }
-        public List<string> Taglines { get; set; }
-        public List<EmbyStudioResponse> Studios { get; set; }
-        public List<EmbyPersonResponse> People { get; set; }
-        public EmbyImageTagsResponse ImageTags { get; set; }
-        public List<string> BackdropImageTags { get; set; }
-        public int? IndexNumber { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public string Id { get; set; }
+    public string Etag { get; set; }
+    public string Path { get; set; }
+    public string OfficialRating { get; set; }
+    public DateTimeOffset DateCreated { get; set; }
+    public long RunTimeTicks { get; set; }
+    public List<string> Genres { get; set; }
+    public List<string> Tags { get; set; }
+    public int ProductionYear { get; set; }
+    public EmbyProviderIdsResponse ProviderIds { get; set; }
+    public string PremiereDate { get; set; }
+    public List<EmbyMediaStreamResponse> MediaStreams { get; set; }
+    public List<EmbyMediaSourceResponse> MediaSources { get; set; }
+    public string LocationType { get; set; }
+    public string Overview { get; set; }
+    public List<string> Taglines { get; set; }
+    public List<EmbyStudioResponse> Studios { get; set; }
+    public List<EmbyPersonResponse> People { get; set; }
+    public EmbyImageTagsResponse ImageTags { get; set; }
+    public List<string> BackdropImageTags { get; set; }
+    public int? IndexNumber { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemsResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemsResponse.cs
index b056dfd9d..2b08edd54 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemsResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryItemsResponse.cs
@@ -1,9 +1,6 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Infrastructure.Emby.Models;
 
-namespace ErsatzTV.Infrastructure.Emby.Models
+public class EmbyLibraryItemsResponse
 {
-    public class EmbyLibraryItemsResponse
-    {
-        public List<EmbyLibraryItemResponse> Items { get; set; }
-    }
-}
+    public List<EmbyLibraryItemResponse> Items { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryResponse.cs
index 581f27ce3..8a8b148a4 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyLibraryResponse.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Infrastructure.Emby.Models
+namespace ErsatzTV.Infrastructure.Emby.Models;
+
+public class EmbyLibraryResponse
 {
-    public class EmbyLibraryResponse
-    {
-        public string Name { get; set; }
-        public string CollectionType { get; set; }
-        public string ItemId { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public string CollectionType { get; set; }
+    public string ItemId { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyMediaSourceResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyMediaSourceResponse.cs
index 82d020e07..4ad576d27 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyMediaSourceResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyMediaSourceResponse.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Emby.Models
+namespace ErsatzTV.Infrastructure.Emby.Models;
+
+public class EmbyMediaSourceResponse
 {
-    public class EmbyMediaSourceResponse
-    {
-        public string Id { get; set; }
-        public string Protocol { get; set; }
-    }
-}
+    public string Id { get; set; }
+    public string Protocol { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyMediaStreamResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyMediaStreamResponse.cs
index 56003240a..9bad08e12 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyMediaStreamResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyMediaStreamResponse.cs
@@ -1,18 +1,17 @@
-namespace ErsatzTV.Infrastructure.Emby.Models
+namespace ErsatzTV.Infrastructure.Emby.Models;
+
+public class EmbyMediaStreamResponse
 {
-    public class EmbyMediaStreamResponse
-    {
-        public string Type { get; set; }
-        public string Codec { get; set; }
-        public string Language { get; set; }
-        public bool? IsInterlaced { get; set; }
-        public int? Height { get; set; }
-        public int? Width { get; set; }
-        public int Index { get; set; }
-        public bool IsDefault { get; set; }
-        public bool IsForced { get; set; }
-        public string Profile { get; set; }
-        public string AspectRatio { get; set; }
-        public int? Channels { get; set; }
-    }
-}
+    public string Type { get; set; }
+    public string Codec { get; set; }
+    public string Language { get; set; }
+    public bool? IsInterlaced { get; set; }
+    public int? Height { get; set; }
+    public int? Width { get; set; }
+    public int Index { get; set; }
+    public bool IsDefault { get; set; }
+    public bool IsForced { get; set; }
+    public string Profile { get; set; }
+    public string AspectRatio { get; set; }
+    public int? Channels { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyPersonResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyPersonResponse.cs
index eafe6c080..041ea0a95 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyPersonResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyPersonResponse.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Infrastructure.Emby.Models
+namespace ErsatzTV.Infrastructure.Emby.Models;
+
+public class EmbyPersonResponse
 {
-    public class EmbyPersonResponse
-    {
-        public string Name { get; set; }
-        public string Id { get; set; }
-        public string Role { get; set; }
-        public string Type { get; set; }
-        public string PrimaryImageTag { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public string Id { get; set; }
+    public string Role { get; set; }
+    public string Type { get; set; }
+    public string PrimaryImageTag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyProviderIdsResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyProviderIdsResponse.cs
index 30ad8e471..f5c839523 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyProviderIdsResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyProviderIdsResponse.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Infrastructure.Emby.Models
+namespace ErsatzTV.Infrastructure.Emby.Models;
+
+public class EmbyProviderIdsResponse
 {
-    public class EmbyProviderIdsResponse
-    {
-        public string Imdb { get; set; }
-        public string Tmdb { get; set; }
-        public string Tvdb { get; set; }
-    }
-}
+    public string Imdb { get; set; }
+    public string Tmdb { get; set; }
+    public string Tvdb { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbyStudioResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbyStudioResponse.cs
index c64b0d13b..11acb98e8 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbyStudioResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbyStudioResponse.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Infrastructure.Emby.Models
+namespace ErsatzTV.Infrastructure.Emby.Models;
+
+public class EmbyStudioResponse
 {
-    public class EmbyStudioResponse
-    {
-        public string Name { get; set; }
-    }
-}
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Emby/Models/EmbySystemInformationResponse.cs b/ErsatzTV.Infrastructure/Emby/Models/EmbySystemInformationResponse.cs
index efc9b79a3..6afb14def 100644
--- a/ErsatzTV.Infrastructure/Emby/Models/EmbySystemInformationResponse.cs
+++ b/ErsatzTV.Infrastructure/Emby/Models/EmbySystemInformationResponse.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Emby.Models
+namespace ErsatzTV.Infrastructure.Emby.Models;
+
+public class EmbySystemInformationResponse
 {
-    public class EmbySystemInformationResponse
-    {
-        public string ServerName { get; set; }
-        public string OperatingSystem { get; set; }
-    }
-}
+    public string ServerName { get; set; }
+    public string OperatingSystem { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj b/ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj
index a687650d7..1445e7b4a 100644
--- a/ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj
+++ b/ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj
@@ -4,6 +4,7 @@
         <TargetFramework>net6.0</TargetFramework>
         <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
         <NoWarn>VSTHRD200</NoWarn>
+        <ImplicitUsings>enable</ImplicitUsings>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/ErsatzTV.Infrastructure/Extensions/ConfigElementQueryableExtensions.cs b/ErsatzTV.Infrastructure/Extensions/ConfigElementQueryableExtensions.cs
index 2a6f70255..875dc0498 100644
--- a/ErsatzTV.Infrastructure/Extensions/ConfigElementQueryableExtensions.cs
+++ b/ErsatzTV.Infrastructure/Extensions/ConfigElementQueryableExtensions.cs
@@ -1,18 +1,13 @@
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.Infrastructure.Extensions
+namespace ErsatzTV.Infrastructure.Extensions;
+
+public static class ConfigElementQueryableExtensions
 {
-    public static class ConfigElementQueryableExtensions
-    {
-        public static Task<Option<T>> GetValue<T>(
-            this IQueryable<ConfigElement> configElements,
-            ConfigElementKey key) =>
-            configElements
-                .SelectOneAsync(ce => ce.Key, ce => ce.Key == key.Key)
-                .MapT(ce => (T) Convert.ChangeType(ce.Value, typeof(T)));
-    }
-}
+    public static Task<Option<T>> GetValue<T>(
+        this IQueryable<ConfigElement> configElements,
+        ConfigElementKey key) =>
+        configElements
+            .SelectOneAsync(ce => ce.Key, ce => ce.Key == key.Key)
+            .MapT(ce => (T) Convert.ChangeType(ce.Value, typeof(T)));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Extensions/LanguageCodeQueryableExtensions.cs b/ErsatzTV.Infrastructure/Extensions/LanguageCodeQueryableExtensions.cs
index 4bd9205bf..fb67ccbd0 100644
--- a/ErsatzTV.Infrastructure/Extensions/LanguageCodeQueryableExtensions.cs
+++ b/ErsatzTV.Infrastructure/Extensions/LanguageCodeQueryableExtensions.cs
@@ -1,78 +1,74 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Infrastructure.Extensions
+namespace ErsatzTV.Infrastructure.Extensions;
+
+public static class LanguageCodeQueryableExtensions
 {
-    public static class LanguageCodeQueryableExtensions
+    public static async Task<List<string>> GetAllLanguageCodes(
+        this IQueryable<LanguageCode> languageCodes,
+        string mediaCode)
     {
-        public static async Task<List<string>> GetAllLanguageCodes(
-            this IQueryable<LanguageCode> languageCodes,
-            string mediaCode)
+        if (string.IsNullOrWhiteSpace(mediaCode))
         {
-            if (string.IsNullOrWhiteSpace(mediaCode))
-            {
-                return new List<string>();
-            }
-
-            string code = mediaCode.ToLowerInvariant();
-
-            List<LanguageCode> maybeLanguages = await languageCodes
-                .Filter(lc => lc.ThreeCode1 == code || lc.ThreeCode2 == code)
-                .ToListAsync();
-
-            var result = new HashSet<string>();
-            foreach (LanguageCode language in maybeLanguages)
-            {
-                if (!string.IsNullOrWhiteSpace(language.ThreeCode1))
-                {
-                    result.Add(language.ThreeCode1);
-                }
-
-                if (!string.IsNullOrWhiteSpace(language.ThreeCode2))
-                {
-                    result.Add(language.ThreeCode2);
-                }
-            }
-
-            return result.ToList();
+            return new List<string>();
         }
 
-        public static async Task<List<string>> GetAllLanguageCodes(
-            this IQueryable<LanguageCode> languageCodes,
-            List<string> mediaCodes)
+        string code = mediaCode.ToLowerInvariant();
+
+        List<LanguageCode> maybeLanguages = await languageCodes
+            .Filter(lc => lc.ThreeCode1 == code || lc.ThreeCode2 == code)
+            .ToListAsync();
+
+        var result = new System.Collections.Generic.HashSet<string>();
+        foreach (LanguageCode language in maybeLanguages)
         {
-            var validCodes = mediaCodes
-                .Filter(c => !string.IsNullOrWhiteSpace(c))
-                .Map(c => c.ToLowerInvariant())
-                .ToList();
-
-            if (validCodes.Count == 0)
+            if (!string.IsNullOrWhiteSpace(language.ThreeCode1))
             {
-                return new List<string>();
+                result.Add(language.ThreeCode1);
             }
 
-            List<LanguageCode> maybeLanguages = await languageCodes
-                .Filter(lc => validCodes.Contains(lc.ThreeCode1) || validCodes.Contains(lc.ThreeCode2))
-                .ToListAsync();
-
-            var result = new HashSet<string>();
-            foreach (LanguageCode language in maybeLanguages)
+            if (!string.IsNullOrWhiteSpace(language.ThreeCode2))
             {
-                if (!string.IsNullOrWhiteSpace(language.ThreeCode1))
-                {
-                    result.Add(language.ThreeCode1);
-                }
-
-                if (!string.IsNullOrWhiteSpace(language.ThreeCode2))
-                {
-                    result.Add(language.ThreeCode2);
-                }
+                result.Add(language.ThreeCode2);
             }
-
-            return result.ToList();
         }
+
+        return result.ToList();
     }
-}
+
+    public static async Task<List<string>> GetAllLanguageCodes(
+        this IQueryable<LanguageCode> languageCodes,
+        List<string> mediaCodes)
+    {
+        var validCodes = mediaCodes
+            .Filter(c => !string.IsNullOrWhiteSpace(c))
+            .Map(c => c.ToLowerInvariant())
+            .ToList();
+
+        if (validCodes.Count == 0)
+        {
+            return new List<string>();
+        }
+
+        List<LanguageCode> maybeLanguages = await languageCodes
+            .Filter(lc => validCodes.Contains(lc.ThreeCode1) || validCodes.Contains(lc.ThreeCode2))
+            .ToListAsync();
+
+        var result = new System.Collections.Generic.HashSet<string>();
+        foreach (LanguageCode language in maybeLanguages)
+        {
+            if (!string.IsNullOrWhiteSpace(language.ThreeCode1))
+            {
+                result.Add(language.ThreeCode1);
+            }
+
+            if (!string.IsNullOrWhiteSpace(language.ThreeCode2))
+            {
+                result.Add(language.ThreeCode2);
+            }
+        }
+
+        return result.ToList();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Extensions/PlayoutItemQueryableExtensions.cs b/ErsatzTV.Infrastructure/Extensions/PlayoutItemQueryableExtensions.cs
index db4a49b57..bf6728319 100644
--- a/ErsatzTV.Infrastructure/Extensions/PlayoutItemQueryableExtensions.cs
+++ b/ErsatzTV.Infrastructure/Extensions/PlayoutItemQueryableExtensions.cs
@@ -1,23 +1,17 @@
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
-using LanguageExt;
+using ErsatzTV.Core.Domain;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Extensions
+namespace ErsatzTV.Infrastructure.Extensions;
+
+public static class PlayoutItemQueryableExtensions
 {
-    public static class PlayoutItemQueryableExtensions
-    {
-        public static Task<Option<PlayoutItem>> ForChannelAndTime(
-            this IQueryable<PlayoutItem> dbSet,
-            int channelId,
-            DateTimeOffset time) =>
-            dbSet.Filter(pi => pi.Playout.ChannelId == channelId)
-                .Filter(pi => pi.Start <= time.UtcDateTime && pi.Finish > time.UtcDateTime)
-                .OrderBy(pi => pi.Start)
-                .FirstOrDefaultAsync()
-                .Map(Optional);
-    }
-}
+    public static Task<Option<PlayoutItem>> ForChannelAndTime(
+        this IQueryable<PlayoutItem> dbSet,
+        int channelId,
+        DateTimeOffset time) =>
+        dbSet.Filter(pi => pi.Playout.ChannelId == channelId)
+            .Filter(pi => pi.Start <= time.UtcDateTime && pi.Finish > time.UtcDateTime)
+            .OrderBy(pi => pi.Start)
+            .FirstOrDefaultAsync()
+            .Map(Optional);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Extensions/QueryableExtensions.cs b/ErsatzTV.Infrastructure/Extensions/QueryableExtensions.cs
index 394b4436f..b35562844 100644
--- a/ErsatzTV.Infrastructure/Extensions/QueryableExtensions.cs
+++ b/ErsatzTV.Infrastructure/Extensions/QueryableExtensions.cs
@@ -1,18 +1,13 @@
-using System;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading.Tasks;
-using LanguageExt;
+using System.Linq.Expressions;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Infrastructure.Extensions
+namespace ErsatzTV.Infrastructure.Extensions;
+
+public static class QueryableExtensions
 {
-    public static class QueryableExtensions
-    {
-        public static async Task<Option<T>> SelectOneAsync<T, TKey>(
-            this IQueryable<T> enumerable,
-            Expression<Func<T, TKey>> keySelector,
-            Expression<Func<T, bool>> predicate) where T : class =>
-            await enumerable.OrderBy(keySelector).FirstOrDefaultAsync(predicate);
-    }
-}
+    public static async Task<Option<T>> SelectOneAsync<T, TKey>(
+        this IQueryable<T> enumerable,
+        Expression<Func<T, TKey>> keySelector,
+        Expression<Func<T, bool>> predicate) where T : class =>
+        await enumerable.OrderBy(keySelector).FirstOrDefaultAsync(predicate);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/GitHub/GitHubApiClient.cs b/ErsatzTV.Infrastructure/GitHub/GitHubApiClient.cs
index b4bf6b931..aa3ffc19e 100644
--- a/ErsatzTV.Infrastructure/GitHub/GitHubApiClient.cs
+++ b/ErsatzTV.Infrastructure/GitHub/GitHubApiClient.cs
@@ -1,39 +1,34 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.GitHub;
-using LanguageExt;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.GitHub
-{
-    public class GitHubApiClient : IGitHubApiClient
-    {
-        public async Task<Either<BaseError, string>> GetLatestReleaseNotes(CancellationToken cancellationToken)
-        {
-            try
-            {
-                IGitHubApi service = RestService.For<IGitHubApi>("https://api.github.com");
-                return await service.GetReleases(cancellationToken).Map(releases => releases.Head().Body);
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
+namespace ErsatzTV.Infrastructure.GitHub;
 
-        public async Task<Either<BaseError, string>> GetReleaseNotes(string tag, CancellationToken cancellationToken)
+public class GitHubApiClient : IGitHubApiClient
+{
+    public async Task<Either<BaseError, string>> GetLatestReleaseNotes(CancellationToken cancellationToken)
+    {
+        try
         {
-            try
-            {
-                IGitHubApi service = RestService.For<IGitHubApi>("https://api.github.com");
-                return await service.GetTag(tag, cancellationToken).Map(t => t.Body);
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
+            IGitHubApi service = RestService.For<IGitHubApi>("https://api.github.com");
+            return await service.GetReleases(cancellationToken).Map(releases => releases.Head().Body);
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
         }
     }
-}
+
+    public async Task<Either<BaseError, string>> GetReleaseNotes(string tag, CancellationToken cancellationToken)
+    {
+        try
+        {
+            IGitHubApi service = RestService.For<IGitHubApi>("https://api.github.com");
+            return await service.GetTag(tag, cancellationToken).Map(t => t.Body);
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/GitHub/IGitHubApi.cs b/ErsatzTV.Infrastructure/GitHub/IGitHubApi.cs
index 6ff72d4bb..886513158 100644
--- a/ErsatzTV.Infrastructure/GitHub/IGitHubApi.cs
+++ b/ErsatzTV.Infrastructure/GitHub/IGitHubApi.cs
@@ -1,18 +1,14 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.GitHub.Models;
+using ErsatzTV.Infrastructure.GitHub.Models;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.GitHub
-{
-    [Headers("Accept: application/vnd.github.v3+json", "User-Agent: jasongdove/ErsatzTV")]
-    public interface IGitHubApi
-    {
-        [Get("/repos/jasongdove/ErsatzTV/releases")]
-        public Task<List<GitHubTag>> GetReleases(CancellationToken cancellationToken);
+namespace ErsatzTV.Infrastructure.GitHub;
 
-        [Get("/repos/jasongdove/ErsatzTV/releases/tags/{tag}")]
-        public Task<GitHubTag> GetTag(string tag, CancellationToken cancellationToken);
-    }
-}
+[Headers("Accept: application/vnd.github.v3+json", "User-Agent: jasongdove/ErsatzTV")]
+public interface IGitHubApi
+{
+    [Get("/repos/jasongdove/ErsatzTV/releases")]
+    public Task<List<GitHubTag>> GetReleases(CancellationToken cancellationToken);
+
+    [Get("/repos/jasongdove/ErsatzTV/releases/tags/{tag}")]
+    public Task<GitHubTag> GetTag(string tag, CancellationToken cancellationToken);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/GitHub/Models/GitHubTag.cs b/ErsatzTV.Infrastructure/GitHub/Models/GitHubTag.cs
index 67271a9a4..9382bb73a 100644
--- a/ErsatzTV.Infrastructure/GitHub/Models/GitHubTag.cs
+++ b/ErsatzTV.Infrastructure/GitHub/Models/GitHubTag.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Infrastructure.GitHub.Models
+namespace ErsatzTV.Infrastructure.GitHub.Models;
+
+public class GitHubTag
 {
-    public class GitHubTag
-    {
-        public string Body { get; set; }
-    }
-}
+    public string Body { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/GlobalUsings.cs b/ErsatzTV.Infrastructure/GlobalUsings.cs
new file mode 100644
index 000000000..66cb869a8
--- /dev/null
+++ b/ErsatzTV.Infrastructure/GlobalUsings.cs
@@ -0,0 +1,4 @@
+global using LanguageExt;
+global using static LanguageExt.Prelude;
+global using Unit = LanguageExt.Unit;
+global using Array = System.Array;
diff --git a/ErsatzTV.Infrastructure/Health/Checks/BaseHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/BaseHealthCheck.cs
index 0cad0ee50..2c5e33533 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/BaseHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/BaseHealthCheck.cs
@@ -1,58 +1,54 @@
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Threading.Tasks;
+using System.Diagnostics;
 using ErsatzTV.Core.Health;
 using Lucene.Net.Util;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Health.Checks
+namespace ErsatzTV.Infrastructure.Health.Checks;
+
+public abstract class BaseHealthCheck
 {
-    public abstract class BaseHealthCheck
+    protected abstract string Title { get; }
+
+    protected HealthCheckResult Result(HealthCheckStatus status, string message) =>
+        new(Title, status, message, None);
+
+    protected HealthCheckResult NotApplicableResult() =>
+        new(Title, HealthCheckStatus.NotApplicable, string.Empty, None);
+        
+    protected HealthCheckResult OkResult() =>
+        new(Title, HealthCheckStatus.Pass, string.Empty, None);
+
+    protected HealthCheckResult FailResult(string message) =>
+        new(Title, HealthCheckStatus.Fail, message, None);
+
+    protected HealthCheckResult WarningResult(string message) =>
+        new(Title, HealthCheckStatus.Warning, message, None);
+
+    protected HealthCheckResult WarningResult(string message, string link) =>
+        new(Title, HealthCheckStatus.Warning, message, link);
+
+    protected HealthCheckResult InfoResult(string message) =>
+        new(Title, HealthCheckStatus.Info, message, None);
+        
+    protected static async Task<string> GetProcessOutput(string path, IEnumerable<string> arguments)
     {
-        protected abstract string Title { get; }
-
-        protected HealthCheckResult Result(HealthCheckStatus status, string message) =>
-            new(Title, status, message, None);
-
-        protected HealthCheckResult NotApplicableResult() =>
-            new(Title, HealthCheckStatus.NotApplicable, string.Empty, None);
-        
-        protected HealthCheckResult OkResult() =>
-            new(Title, HealthCheckStatus.Pass, string.Empty, None);
-
-        protected HealthCheckResult FailResult(string message) =>
-            new(Title, HealthCheckStatus.Fail, message, None);
-
-        protected HealthCheckResult WarningResult(string message) =>
-            new(Title, HealthCheckStatus.Warning, message, None);
-
-        protected HealthCheckResult WarningResult(string message, string link) =>
-            new(Title, HealthCheckStatus.Warning, message, link);
-
-        protected HealthCheckResult InfoResult(string message) =>
-            new(Title, HealthCheckStatus.Info, message, None);
-        
-        protected static async Task<string> GetProcessOutput(string path, IEnumerable<string> arguments)
+        var startInfo = new ProcessStartInfo
         {
-            var startInfo = new ProcessStartInfo
-            {
-                FileName = path,
-                RedirectStandardOutput = true,
-                RedirectStandardError = true,
-                UseShellExecute = false
-            };
+            FileName = path,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false
+        };
 
-            startInfo.ArgumentList.AddRange(arguments);
+        startInfo.ArgumentList.AddRange(arguments);
 
-            var process = new Process
-            {
-                StartInfo = startInfo
-            };
+        var process = new Process
+        {
+            StartInfo = startInfo
+        };
 
-            process.Start();
-            string result = await process.StandardOutput.ReadToEndAsync();
-            await process.WaitForExitAsync();
-            return result;
-        }
+        process.Start();
+        string result = await process.StandardOutput.ReadToEndAsync();
+        await process.WaitForExitAsync();
+        return result;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Health/Checks/EpisodeMetadataHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/EpisodeMetadataHealthCheck.cs
index eb91aea56..63d423385 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/EpisodeMetadataHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/EpisodeMetadataHealthCheck.cs
@@ -1,51 +1,44 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Health.Checks
+namespace ErsatzTV.Infrastructure.Health.Checks;
+
+public class EpisodeMetadataHealthCheck : BaseHealthCheck, IEpisodeMetadataHealthCheck
 {
-    public class EpisodeMetadataHealthCheck : BaseHealthCheck, IEpisodeMetadataHealthCheck
-    {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
 
-        public EpisodeMetadataHealthCheck(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+    public EpisodeMetadataHealthCheck(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
 
-        protected override string Title => "Episode Metadata";
+    protected override string Title => "Episode Metadata";
         
-        public async Task<HealthCheckResult> Check()
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+    public async Task<HealthCheckResult> Check()
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             
-            List<Episode> episodes = await dbContext.Episodes
-                .Filter(e => e.EpisodeMetadata.Count == 0)
-                .Include(e => e.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .ToListAsync();
+        List<Episode> episodes = await dbContext.Episodes
+            .Filter(e => e.EpisodeMetadata.Count == 0)
+            .Include(e => e.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .ToListAsync();
 
-            if (episodes.Any())
-            {
-                var paths = episodes.SelectMany(e => e.MediaVersions.Map(mv => mv.MediaFiles))
-                    .Flatten()
-                    .Bind(f => Optional<string>(Path.GetDirectoryName(f.Path)))
-                    .Distinct()
-                    .Take(5)
-                    .ToList();
+        if (episodes.Any())
+        {
+            var paths = episodes.SelectMany(e => e.MediaVersions.Map(mv => mv.MediaFiles))
+                .Flatten()
+                .Bind(f => Optional<string>(Path.GetDirectoryName(f.Path)))
+                .Distinct()
+                .Take(5)
+                .ToList();
 
-                var folders = string.Join(", ", paths);
+            var folders = string.Join(", ", paths);
 
-                return WarningResult($"There are {episodes.Count} episodes with missing metadata, including in the following folders: {folders}");
-            }
-
-            return OkResult();
+            return WarningResult($"There are {episodes.Count} episodes with missing metadata, including in the following folders: {folders}");
         }
+
+        return OkResult();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Health/Checks/ErrorReportsHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/ErrorReportsHealthCheck.cs
index 1c149bb84..8cb21355c 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/ErrorReportsHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/ErrorReportsHealthCheck.cs
@@ -1,8 +1,6 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
-using LanguageExt;
 using Microsoft.Extensions.Options;
 
 namespace ErsatzTV.Infrastructure.Health.Checks;
diff --git a/ErsatzTV.Infrastructure/Health/Checks/FFmpegReportsHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/FFmpegReportsHealthCheck.cs
index 31e11b92d..3f17c9e05 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/FFmpegReportsHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/FFmpegReportsHealthCheck.cs
@@ -1,37 +1,34 @@
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
 
-namespace ErsatzTV.Infrastructure.Health.Checks
+namespace ErsatzTV.Infrastructure.Health.Checks;
+
+public class FFmpegReportsHealthCheck : BaseHealthCheck, IFFmpegReportsHealthCheck
 {
-    public class FFmpegReportsHealthCheck : BaseHealthCheck, IFFmpegReportsHealthCheck
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public FFmpegReportsHealthCheck(IConfigElementRepository configElementRepository) =>
+        _configElementRepository = configElementRepository;
+
+    public async Task<HealthCheckResult> Check()
     {
-        private readonly IConfigElementRepository _configElementRepository;
+        Option<bool> saveReports =
+            await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
 
-        public FFmpegReportsHealthCheck(IConfigElementRepository configElementRepository) =>
-            _configElementRepository = configElementRepository;
-
-        public async Task<HealthCheckResult> Check()
+        foreach (bool value in saveReports)
         {
-            Option<bool> saveReports =
-                await _configElementRepository.GetValue<bool>(ConfigElementKey.FFmpegSaveReports);
-
-            foreach (bool value in saveReports)
+            if (value)
             {
-                if (value)
-                {
-                    return Result(
-                        HealthCheckStatus.Warning,
-                        "FFmpeg troubleshooting reports are enabled and may use a lot of disk space");
-                }
+                return Result(
+                    HealthCheckStatus.Warning,
+                    "FFmpeg troubleshooting reports are enabled and may use a lot of disk space");
             }
-
-            return OkResult();
         }
 
-        protected override string Title => "FFmpeg Reports";
+        return OkResult();
     }
-}
+
+    protected override string Title => "FFmpeg Reports";
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Health/Checks/FFmpegVersionHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/FFmpegVersionHealthCheck.cs
index 47171ec16..784432b34 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/FFmpegVersionHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/FFmpegVersionHealthCheck.cs
@@ -1,107 +1,103 @@
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
 using ErsatzTV.Core.Interfaces.Repositories;
-using LanguageExt;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Health.Checks
+namespace ErsatzTV.Infrastructure.Health.Checks;
+
+public class FFmpegVersionHealthCheck : BaseHealthCheck, IFFmpegVersionHealthCheck
 {
-    public class FFmpegVersionHealthCheck : BaseHealthCheck, IFFmpegVersionHealthCheck
+    private const string BundledVersion = "N-105324-g0f5fd44dc9";
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public FFmpegVersionHealthCheck(IConfigElementRepository configElementRepository)
     {
-        private const string BundledVersion = "N-105324-g0f5fd44dc9";
-        private readonly IConfigElementRepository _configElementRepository;
-
-        public FFmpegVersionHealthCheck(IConfigElementRepository configElementRepository)
-        {
-            _configElementRepository = configElementRepository;
-        }
-
-        public async Task<HealthCheckResult> Check()
-        {
-            Option<ConfigElement> maybeFFmpegPath = await _configElementRepository.Get(ConfigElementKey.FFmpegPath);
-            if (maybeFFmpegPath.IsNone)
-            {
-                return FailResult("Unable to locate ffmpeg");
-            }
-
-            Option<ConfigElement> maybeFFprobePath = await _configElementRepository.Get(ConfigElementKey.FFprobePath);
-            if (maybeFFprobePath.IsNone)
-            {
-                return FailResult("Unable to locate ffprobe");
-            }
-            foreach (ConfigElement ffmpegPath in maybeFFmpegPath)
-            {
-                Option<string> maybeVersion = await GetVersion(ffmpegPath.Value);
-                if (maybeVersion.IsNone)
-                {
-                    return WarningResult("Unable to determine ffmpeg version");
-                }
-
-                foreach (string version in maybeVersion)
-                {
-                    foreach (HealthCheckResult result in ValidateVersion(version, "ffmpeg"))
-                    {
-                        return result;
-                    }
-                }
-            }
-
-            foreach (ConfigElement ffprobePath in maybeFFprobePath)
-            {
-                Option<string> maybeVersion = await GetVersion(ffprobePath.Value);
-                if (maybeVersion.IsNone)
-                {
-                    return WarningResult("Unable to determine ffprobe version");
-                }
-
-                foreach (string version in maybeVersion)
-                {
-                    foreach (HealthCheckResult result in ValidateVersion(version, "ffprobe"))
-                    {
-                        return result;
-                    }
-                }
-            }
-
-            return new HealthCheckResult("FFmpeg Version", HealthCheckStatus.Pass, string.Empty, None);
-        }
-        
-        private Option<HealthCheckResult> ValidateVersion(string version, string app)
-        {
-            if (version.StartsWith("3.") || version.StartsWith("4."))
-            {
-                return FailResult($"{app} version {version} is too old; please install 5.0!");
-            }
-
-            if (!version.StartsWith("5.0") && version != BundledVersion)
-            {
-                return WarningResult(
-                    $"{app} version {version} is unexpected and may have problems; please install 5.0!");
-            }
-
-            return None;
-        }
-
-        private static async Task<Option<string>> GetVersion(string path)
-        {
-            Option<string> maybeLine = await GetProcessOutput(path, new[] { "-version" })
-                .Map(s => s.Split("\n").HeadOrNone().Map(h => h.Trim()));
-            foreach (string line in maybeLine)
-            {
-                const string PATTERN = @"version\s+([^\s]+)";
-                Match match = Regex.Match(line, PATTERN);
-                if (match.Success)
-                {
-                    return match.Groups[1].Value;
-                }
-            }
-
-            return None;
-        }
-
-        protected override string Title => "FFmpeg Version";
+        _configElementRepository = configElementRepository;
     }
-}
+
+    public async Task<HealthCheckResult> Check()
+    {
+        Option<ConfigElement> maybeFFmpegPath = await _configElementRepository.Get(ConfigElementKey.FFmpegPath);
+        if (maybeFFmpegPath.IsNone)
+        {
+            return FailResult("Unable to locate ffmpeg");
+        }
+
+        Option<ConfigElement> maybeFFprobePath = await _configElementRepository.Get(ConfigElementKey.FFprobePath);
+        if (maybeFFprobePath.IsNone)
+        {
+            return FailResult("Unable to locate ffprobe");
+        }
+        foreach (ConfigElement ffmpegPath in maybeFFmpegPath)
+        {
+            Option<string> maybeVersion = await GetVersion(ffmpegPath.Value);
+            if (maybeVersion.IsNone)
+            {
+                return WarningResult("Unable to determine ffmpeg version");
+            }
+
+            foreach (string version in maybeVersion)
+            {
+                foreach (HealthCheckResult result in ValidateVersion(version, "ffmpeg"))
+                {
+                    return result;
+                }
+            }
+        }
+
+        foreach (ConfigElement ffprobePath in maybeFFprobePath)
+        {
+            Option<string> maybeVersion = await GetVersion(ffprobePath.Value);
+            if (maybeVersion.IsNone)
+            {
+                return WarningResult("Unable to determine ffprobe version");
+            }
+
+            foreach (string version in maybeVersion)
+            {
+                foreach (HealthCheckResult result in ValidateVersion(version, "ffprobe"))
+                {
+                    return result;
+                }
+            }
+        }
+
+        return new HealthCheckResult("FFmpeg Version", HealthCheckStatus.Pass, string.Empty, None);
+    }
+        
+    private Option<HealthCheckResult> ValidateVersion(string version, string app)
+    {
+        if (version.StartsWith("3.") || version.StartsWith("4."))
+        {
+            return FailResult($"{app} version {version} is too old; please install 5.0!");
+        }
+
+        if (!version.StartsWith("5.0") && version != BundledVersion)
+        {
+            return WarningResult(
+                $"{app} version {version} is unexpected and may have problems; please install 5.0!");
+        }
+
+        return None;
+    }
+
+    private static async Task<Option<string>> GetVersion(string path)
+    {
+        Option<string> maybeLine = await GetProcessOutput(path, new[] { "-version" })
+            .Map(s => s.Split("\n").HeadOrNone().Map(h => h.Trim()));
+        foreach (string line in maybeLine)
+        {
+            const string PATTERN = @"version\s+([^\s]+)";
+            Match match = Regex.Match(line, PATTERN);
+            if (match.Success)
+            {
+                return match.Groups[1].Value;
+            }
+        }
+
+        return None;
+    }
+
+    protected override string Title => "FFmpeg Version";
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Health/Checks/FileNotFoundHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/FileNotFoundHealthCheck.cs
index 0c8984c89..bf3297c16 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/FileNotFoundHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/FileNotFoundHealthCheck.cs
@@ -1,7 +1,4 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
diff --git a/ErsatzTV.Infrastructure/Health/Checks/HardwareAccelerationHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/HardwareAccelerationHealthCheck.cs
index 1d28c5a7d..11802ca19 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/HardwareAccelerationHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/HardwareAccelerationHealthCheck.cs
@@ -1,129 +1,121 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
+using System.Reflection;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Health.Checks
+namespace ErsatzTV.Infrastructure.Health.Checks;
+
+public class HardwareAccelerationHealthCheck : BaseHealthCheck, IHardwareAccelerationHealthCheck
 {
-    public class HardwareAccelerationHealthCheck : BaseHealthCheck, IHardwareAccelerationHealthCheck
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IConfigElementRepository _configElementRepository;
+
+    public HardwareAccelerationHealthCheck(
+        IDbContextFactory<TvContext> dbContextFactory,
+        IConfigElementRepository configElementRepository)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-        private readonly IConfigElementRepository _configElementRepository;
-
-        public HardwareAccelerationHealthCheck(
-            IDbContextFactory<TvContext> dbContextFactory,
-            IConfigElementRepository configElementRepository)
-        {
-            _dbContextFactory = dbContextFactory;
-            _configElementRepository = configElementRepository;
-        }
-
-        public async Task<HealthCheckResult> Check()
-        {
-            Option<ConfigElement> maybeFFmpegPath = await _configElementRepository.Get(ConfigElementKey.FFmpegPath);
-            if (maybeFFmpegPath.IsNone)
-            {
-                return FailResult("Unable to locate ffmpeg");
-            }
-
-            string version = Assembly.GetEntryAssembly()?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
-                ?.InformationalVersion ?? "unknown";
-
-            var accelerationKinds = new List<HardwareAccelerationKind>();
-            
-            if (version.Contains("docker", StringComparison.OrdinalIgnoreCase))
-            {
-                if (version.Contains("nvidia", StringComparison.OrdinalIgnoreCase))
-                {
-                    accelerationKinds.Add(HardwareAccelerationKind.Nvenc);
-                }
-                else if (version.Contains("vaapi", StringComparison.OrdinalIgnoreCase))
-                {
-                    accelerationKinds.Add(HardwareAccelerationKind.Vaapi);
-                }
-            }
-
-            if (!accelerationKinds.Any())
-            {
-                accelerationKinds.AddRange(await GetSupportedAccelerationKinds(maybeFFmpegPath.ValueUnsafe().Value));
-            }
-
-            if (!accelerationKinds.Any())
-            {
-                return InfoResult("No compatible hardware acceleration kinds are supported by ffmpeg");
-            }
-
-            Option<HealthCheckResult> maybeResult = await VerifyProfilesUseAcceleration(accelerationKinds);
-            foreach (HealthCheckResult result in maybeResult)
-            {
-                return result;
-            }
-
-            return OkResult();
-        }
-
-        private async Task<Option<HealthCheckResult>> VerifyProfilesUseAcceleration(
-            IEnumerable<HardwareAccelerationKind> accelerationKinds)
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-
-            List<Channel> badChannels = await dbContext.Channels
-                .Filter(c => c.StreamingMode != StreamingMode.HttpLiveStreamingDirect)
-                .Filter(c => !accelerationKinds.Contains(c.FFmpegProfile.HardwareAcceleration))
-                .ToListAsync();
-
-            if (badChannels.Any())
-            {
-                var accel = string.Join(", ", accelerationKinds);
-                var channels = string.Join(", ", badChannels.Map(c => $"{c.Number} - {c.Name}"));
-                return WarningResult(
-                    $"The following channels are transcoding without hardware acceleration ({accel}): {channels}");
-            }
-
-            return None;
-        }
-
-        private static async Task<List<HardwareAccelerationKind>> GetSupportedAccelerationKinds(string ffmpegPath)
-        {
-            var result = new System.Collections.Generic.HashSet<HardwareAccelerationKind>();
-            
-            string output = await GetProcessOutput(ffmpegPath, new[] { "-v", "quiet", "-hwaccels" });
-            foreach (string method in output.Split("\n").Map(s => s.Trim()).Skip(1))
-            {
-                switch (method)
-                {
-                    case "vaapi":
-                        result.Add(HardwareAccelerationKind.Vaapi);
-                        break;
-                    case "nvenc":
-                        result.Add(HardwareAccelerationKind.Nvenc);
-                        break;
-                    case "cuda":
-                        result.Add(HardwareAccelerationKind.Nvenc);
-                        break;
-                    case "qsv":
-                        result.Add(HardwareAccelerationKind.Qsv);
-                        break;
-                    case "videotoolbox":
-                        result.Add(HardwareAccelerationKind.VideoToolbox);
-                        break;
-                }
-            }
-
-            return result.ToList();
-        }
-
-        protected override string Title => "Hardware Acceleration";
+        _dbContextFactory = dbContextFactory;
+        _configElementRepository = configElementRepository;
     }
-}
+
+    public async Task<HealthCheckResult> Check()
+    {
+        Option<ConfigElement> maybeFFmpegPath = await _configElementRepository.Get(ConfigElementKey.FFmpegPath);
+        if (maybeFFmpegPath.IsNone)
+        {
+            return FailResult("Unable to locate ffmpeg");
+        }
+
+        string version = Assembly.GetEntryAssembly()?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
+            ?.InformationalVersion ?? "unknown";
+
+        var accelerationKinds = new List<HardwareAccelerationKind>();
+            
+        if (version.Contains("docker", StringComparison.OrdinalIgnoreCase))
+        {
+            if (version.Contains("nvidia", StringComparison.OrdinalIgnoreCase))
+            {
+                accelerationKinds.Add(HardwareAccelerationKind.Nvenc);
+            }
+            else if (version.Contains("vaapi", StringComparison.OrdinalIgnoreCase))
+            {
+                accelerationKinds.Add(HardwareAccelerationKind.Vaapi);
+            }
+        }
+
+        if (!accelerationKinds.Any())
+        {
+            accelerationKinds.AddRange(await GetSupportedAccelerationKinds(maybeFFmpegPath.ValueUnsafe().Value));
+        }
+
+        if (!accelerationKinds.Any())
+        {
+            return InfoResult("No compatible hardware acceleration kinds are supported by ffmpeg");
+        }
+
+        Option<HealthCheckResult> maybeResult = await VerifyProfilesUseAcceleration(accelerationKinds);
+        foreach (HealthCheckResult result in maybeResult)
+        {
+            return result;
+        }
+
+        return OkResult();
+    }
+
+    private async Task<Option<HealthCheckResult>> VerifyProfilesUseAcceleration(
+        IEnumerable<HardwareAccelerationKind> accelerationKinds)
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+        List<Channel> badChannels = await dbContext.Channels
+            .Filter(c => c.StreamingMode != StreamingMode.HttpLiveStreamingDirect)
+            .Filter(c => !accelerationKinds.Contains(c.FFmpegProfile.HardwareAcceleration))
+            .ToListAsync();
+
+        if (badChannels.Any())
+        {
+            var accel = string.Join(", ", accelerationKinds);
+            var channels = string.Join(", ", badChannels.Map(c => $"{c.Number} - {c.Name}"));
+            return WarningResult(
+                $"The following channels are transcoding without hardware acceleration ({accel}): {channels}");
+        }
+
+        return None;
+    }
+
+    private static async Task<List<HardwareAccelerationKind>> GetSupportedAccelerationKinds(string ffmpegPath)
+    {
+        var result = new System.Collections.Generic.HashSet<HardwareAccelerationKind>();
+            
+        string output = await GetProcessOutput(ffmpegPath, new[] { "-v", "quiet", "-hwaccels" });
+        foreach (string method in output.Split("\n").Map(s => s.Trim()).Skip(1))
+        {
+            switch (method)
+            {
+                case "vaapi":
+                    result.Add(HardwareAccelerationKind.Vaapi);
+                    break;
+                case "nvenc":
+                    result.Add(HardwareAccelerationKind.Nvenc);
+                    break;
+                case "cuda":
+                    result.Add(HardwareAccelerationKind.Nvenc);
+                    break;
+                case "qsv":
+                    result.Add(HardwareAccelerationKind.Qsv);
+                    break;
+                case "videotoolbox":
+                    result.Add(HardwareAccelerationKind.VideoToolbox);
+                    break;
+            }
+        }
+
+        return result.ToList();
+    }
+
+    protected override string Title => "Hardware Acceleration";
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Health/Checks/MovieMetadataHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/MovieMetadataHealthCheck.cs
index 9b07d850e..b99e21e3f 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/MovieMetadataHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/MovieMetadataHealthCheck.cs
@@ -1,51 +1,44 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
 using ErsatzTV.Infrastructure.Data;
-using LanguageExt;
 using Microsoft.EntityFrameworkCore;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Health.Checks
+namespace ErsatzTV.Infrastructure.Health.Checks;
+
+public class MovieMetadataHealthCheck : BaseHealthCheck, IMovieMetadataHealthCheck
 {
-    public class MovieMetadataHealthCheck : BaseHealthCheck, IMovieMetadataHealthCheck
-    {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
 
-        public MovieMetadataHealthCheck(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+    public MovieMetadataHealthCheck(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
 
-        protected override string Title => "Movie Metadata";
+    protected override string Title => "Movie Metadata";
         
-        public async Task<HealthCheckResult> Check()
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+    public async Task<HealthCheckResult> Check()
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
             
-            List<Movie> movies = await dbContext.Movies
-                .Filter(e => e.MovieMetadata.Count == 0)
-                .Include(e => e.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .ToListAsync();
+        List<Movie> movies = await dbContext.Movies
+            .Filter(e => e.MovieMetadata.Count == 0)
+            .Include(e => e.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .ToListAsync();
 
-            if (movies.Any())
-            {
-                var paths = movies.SelectMany(e => e.MediaVersions.Map(mv => mv.MediaFiles))
-                    .Flatten()
-                    .Bind(f => Optional<string>(Path.GetDirectoryName(f.Path)))
-                    .Distinct()
-                    .Take(5)
-                    .ToList();
+        if (movies.Any())
+        {
+            var paths = movies.SelectMany(e => e.MediaVersions.Map(mv => mv.MediaFiles))
+                .Flatten()
+                .Bind(f => Optional<string>(Path.GetDirectoryName(f.Path)))
+                .Distinct()
+                .Take(5)
+                .ToList();
 
-                var folders = string.Join(", ", paths);
+            var folders = string.Join(", ", paths);
 
-                return WarningResult($"There are {movies.Count} movies with missing metadata, including in the following folders: {folders}");
-            }
-
-            return OkResult();
+            return WarningResult($"There are {movies.Count} movies with missing metadata, including in the following folders: {folders}");
         }
+
+        return OkResult();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Health/Checks/VaapiDriverHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/VaapiDriverHealthCheck.cs
index 1b04ff1e6..bbdcb501e 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/VaapiDriverHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/VaapiDriverHealthCheck.cs
@@ -1,47 +1,43 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Infrastructure.Health.Checks
+namespace ErsatzTV.Infrastructure.Health.Checks;
+
+public class VaapiDriverHealthCheck : BaseHealthCheck, IVaapiDriverHealthCheck
 {
-    public class VaapiDriverHealthCheck : BaseHealthCheck, IVaapiDriverHealthCheck
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public VaapiDriverHealthCheck(IDbContextFactory<TvContext> dbContextFactory)
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
-
-        public VaapiDriverHealthCheck(IDbContextFactory<TvContext> dbContextFactory)
-        {
-            _dbContextFactory = dbContextFactory;
-        }
-
-        protected override string Title => "VAAPI Driver";
-
-        public async Task<HealthCheckResult> Check()
-        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
-            List<FFmpegProfile> profiles = await dbContext.FFmpegProfiles
-                .Filter(p => p.HardwareAcceleration == HardwareAccelerationKind.Vaapi)
-                .ToListAsync();
-            
-            if (profiles.Count == 0)
-            {
-                return NotApplicableResult();
-            }
-
-
-            var defaultProfiles = profiles
-                .Filter(p => p.VaapiDriver == VaapiDriver.Default)
-                .ToList();
-
-            return defaultProfiles.Any()
-                ? InfoResult(
-                    $"{defaultProfiles.Count} FFmpeg Profile{(defaultProfiles.Count > 1 ? "s are" : " is")} set to use Default VAAPI Driver; selecting iHD (Gen 8+) or i965 (up to Gen 9) may offer better performance with Intel iGPU")
-                : OkResult();
-        }
+        _dbContextFactory = dbContextFactory;
     }
-}
+
+    protected override string Title => "VAAPI Driver";
+
+    public async Task<HealthCheckResult> Check()
+    {
+        await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+        List<FFmpegProfile> profiles = await dbContext.FFmpegProfiles
+            .Filter(p => p.HardwareAcceleration == HardwareAccelerationKind.Vaapi)
+            .ToListAsync();
+            
+        if (profiles.Count == 0)
+        {
+            return NotApplicableResult();
+        }
+
+
+        var defaultProfiles = profiles
+            .Filter(p => p.VaapiDriver == VaapiDriver.Default)
+            .ToList();
+
+        return defaultProfiles.Any()
+            ? InfoResult(
+                $"{defaultProfiles.Count} FFmpeg Profile{(defaultProfiles.Count > 1 ? "s are" : " is")} set to use Default VAAPI Driver; selecting iHD (Gen 8+) or i965 (up to Gen 9) may offer better performance with Intel iGPU")
+            : OkResult();
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Health/Checks/ZeroDurationHealthCheck.cs b/ErsatzTV.Infrastructure/Health/Checks/ZeroDurationHealthCheck.cs
index 0ee42cf15..f79a7a1af 100644
--- a/ErsatzTV.Infrastructure/Health/Checks/ZeroDurationHealthCheck.cs
+++ b/ErsatzTV.Infrastructure/Health/Checks/ZeroDurationHealthCheck.cs
@@ -1,76 +1,71 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 
-namespace ErsatzTV.Infrastructure.Health.Checks
+namespace ErsatzTV.Infrastructure.Health.Checks;
+
+public class ZeroDurationHealthCheck : BaseHealthCheck, IZeroDurationHealthCheck
 {
-    public class ZeroDurationHealthCheck : BaseHealthCheck, IZeroDurationHealthCheck
+    private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+    public ZeroDurationHealthCheck(IDbContextFactory<TvContext> dbContextFactory) =>
+        _dbContextFactory = dbContextFactory;
+
+    protected override string Title => "Zero Duration";
+
+    public async Task<HealthCheckResult> Check()
     {
-        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
 
-        public ZeroDurationHealthCheck(IDbContextFactory<TvContext> dbContextFactory) =>
-            _dbContextFactory = dbContextFactory;
+        List<Episode> episodes = await dbContext.Episodes
+            .Filter(e => e.MediaVersions.Any(mv => mv.Duration == TimeSpan.Zero))
+            .Include(e => e.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .ToListAsync();
 
-        protected override string Title => "Zero Duration";
+        List<Movie> movies = await dbContext.Movies
+            .Filter(m => m.MediaVersions.Any(mv => mv.Duration == TimeSpan.Zero))
+            .Include(m => m.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .ToListAsync();
+            
+        List<MusicVideo> musicVideos = await dbContext.MusicVideos
+            .Filter(mv => mv.MediaVersions.Any(v => v.Duration == TimeSpan.Zero))
+            .Include(mv => mv.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .ToListAsync();
+            
+        List<OtherVideo> otherVideos = await dbContext.OtherVideos
+            .Filter(ov => ov.MediaVersions.Any(mv => mv.Duration == TimeSpan.Zero))
+            .Include(ov => ov.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .ToListAsync();
 
-        public async Task<HealthCheckResult> Check()
+        List<Song> songs = await dbContext.Songs
+            .Filter(s => s.MediaVersions.Any(mv => mv.Duration == TimeSpan.Zero))
+            .Include(s => s.MediaVersions)
+            .ThenInclude(mv => mv.MediaFiles)
+            .ToListAsync();
+            
+        var all = movies.Map(m => m.MediaVersions.Head().MediaFiles.Head().Path)
+            .Append(episodes.Map(e => e.MediaVersions.Head().MediaFiles.Head().Path))
+            .Append(musicVideos.Map(mv => mv.GetHeadVersion().MediaFiles.Head().Path))
+            .Append(otherVideos.Map(ov => ov.GetHeadVersion().MediaFiles.Head().Path))
+            .Append(songs.Map(s => s.GetHeadVersion().MediaFiles.Head().Path))
+            .ToList();
+
+        if (all.Any())
         {
-            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+            var paths = all.Take(5).ToList();
 
-            List<Episode> episodes = await dbContext.Episodes
-                .Filter(e => e.MediaVersions.Any(mv => mv.Duration == TimeSpan.Zero))
-                .Include(e => e.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .ToListAsync();
+            var files = string.Join(", ", paths);
 
-            List<Movie> movies = await dbContext.Movies
-                .Filter(m => m.MediaVersions.Any(mv => mv.Duration == TimeSpan.Zero))
-                .Include(m => m.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .ToListAsync();
-            
-            List<MusicVideo> musicVideos = await dbContext.MusicVideos
-                .Filter(mv => mv.MediaVersions.Any(v => v.Duration == TimeSpan.Zero))
-                .Include(mv => mv.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .ToListAsync();
-            
-            List<OtherVideo> otherVideos = await dbContext.OtherVideos
-                .Filter(ov => ov.MediaVersions.Any(mv => mv.Duration == TimeSpan.Zero))
-                .Include(ov => ov.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .ToListAsync();
-
-            List<Song> songs = await dbContext.Songs
-                .Filter(s => s.MediaVersions.Any(mv => mv.Duration == TimeSpan.Zero))
-                .Include(s => s.MediaVersions)
-                .ThenInclude(mv => mv.MediaFiles)
-                .ToListAsync();
-            
-            var all = movies.Map(m => m.MediaVersions.Head().MediaFiles.Head().Path)
-                .Append(episodes.Map(e => e.MediaVersions.Head().MediaFiles.Head().Path))
-                .Append(musicVideos.Map(mv => mv.GetHeadVersion().MediaFiles.Head().Path))
-                .Append(otherVideos.Map(ov => ov.GetHeadVersion().MediaFiles.Head().Path))
-                .Append(songs.Map(s => s.GetHeadVersion().MediaFiles.Head().Path))
-                .ToList();
-
-            if (all.Any())
-            {
-                var paths = all.Take(5).ToList();
-
-                var files = string.Join(", ", paths);
-
-                return WarningResult($"There are {all.Count} files with zero duration, including the following: {files}");
-            }
-
-            return OkResult();
+            return WarningResult($"There are {all.Count} files with zero duration, including the following: {files}");
         }
+
+        return OkResult();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Health/HealthCheckService.cs b/ErsatzTV.Infrastructure/Health/HealthCheckService.cs
index 77731347b..955cab367 100644
--- a/ErsatzTV.Infrastructure/Health/HealthCheckService.cs
+++ b/ErsatzTV.Infrastructure/Health/HealthCheckService.cs
@@ -1,43 +1,38 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Health;
+using ErsatzTV.Core.Health;
 using ErsatzTV.Core.Health.Checks;
-using LanguageExt;
 
-namespace ErsatzTV.Infrastructure.Health
+namespace ErsatzTV.Infrastructure.Health;
+
+public class HealthCheckService : IHealthCheckService
 {
-    public class HealthCheckService : IHealthCheckService
+    private readonly List<IHealthCheck> _checks;
+
+    // ReSharper disable SuggestBaseTypeForParameterInConstructor
+    public HealthCheckService(
+        IFFmpegVersionHealthCheck ffmpegVersionHealthCheck,
+        IFFmpegReportsHealthCheck ffmpegReportsHealthCheck,
+        IHardwareAccelerationHealthCheck hardwareAccelerationHealthCheck,
+        IMovieMetadataHealthCheck movieMetadataHealthCheck,
+        IEpisodeMetadataHealthCheck episodeMetadataHealthCheck,
+        IZeroDurationHealthCheck zeroDurationHealthCheck,
+        IFileNotFoundHealthCheck fileNotFoundHealthCheck,
+        IVaapiDriverHealthCheck vaapiDriverHealthCheck,
+        IErrorReportsHealthCheck errorReportsHealthCheck)
     {
-        private readonly List<IHealthCheck> _checks;
-
-        // ReSharper disable SuggestBaseTypeForParameterInConstructor
-        public HealthCheckService(
-            IFFmpegVersionHealthCheck ffmpegVersionHealthCheck,
-            IFFmpegReportsHealthCheck ffmpegReportsHealthCheck,
-            IHardwareAccelerationHealthCheck hardwareAccelerationHealthCheck,
-            IMovieMetadataHealthCheck movieMetadataHealthCheck,
-            IEpisodeMetadataHealthCheck episodeMetadataHealthCheck,
-            IZeroDurationHealthCheck zeroDurationHealthCheck,
-            IFileNotFoundHealthCheck fileNotFoundHealthCheck,
-            IVaapiDriverHealthCheck vaapiDriverHealthCheck,
-            IErrorReportsHealthCheck errorReportsHealthCheck)
+        _checks = new List<IHealthCheck>
         {
-            _checks = new List<IHealthCheck>
-            {
-                ffmpegVersionHealthCheck,
-                ffmpegReportsHealthCheck,
-                hardwareAccelerationHealthCheck,
-                movieMetadataHealthCheck,
-                episodeMetadataHealthCheck,
-                zeroDurationHealthCheck,
-                fileNotFoundHealthCheck,
-                vaapiDriverHealthCheck,
-                errorReportsHealthCheck
-            };
-        }
-
-        public Task<List<HealthCheckResult>> PerformHealthChecks() =>
-            _checks.Map(c => c.Check()).SequenceParallel().Map(results => results.ToList());
+            ffmpegVersionHealthCheck,
+            ffmpegReportsHealthCheck,
+            hardwareAccelerationHealthCheck,
+            movieMetadataHealthCheck,
+            episodeMetadataHealthCheck,
+            zeroDurationHealthCheck,
+            fileNotFoundHealthCheck,
+            vaapiDriverHealthCheck,
+            errorReportsHealthCheck
+        };
     }
-}
+
+    public Task<List<HealthCheckResult>> PerformHealthChecks() =>
+        _checks.Map(c => c.Check()).SequenceParallel().Map(results => results.ToList());
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Images/ImageCache.cs b/ErsatzTV.Infrastructure/Images/ImageCache.cs
index 8cf2aa0d0..412d8102d 100644
--- a/ErsatzTV.Infrastructure/Images/ImageCache.cs
+++ b/ErsatzTV.Infrastructure/Images/ImageCache.cs
@@ -1,15 +1,11 @@
-using System;
-using System.IO;
-using System.Security.Cryptography;
+using System.Security.Cryptography;
 using System.Text;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Interfaces.Images;
 using ErsatzTV.Core.Interfaces.Metadata;
-using LanguageExt;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using SixLabors.ImageSharp;
@@ -17,136 +13,64 @@ using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
 
-namespace ErsatzTV.Infrastructure.Images
+namespace ErsatzTV.Infrastructure.Images;
+
+public class ImageCache : IImageCache
 {
-    public class ImageCache : IImageCache
+    private static readonly SHA1 Crypto;
+    private readonly ILocalFileSystem _localFileSystem;
+    private readonly ILogger<ImageCache> _logger;
+    private readonly IMemoryCache _memoryCache;
+    private readonly ITempFilePool _tempFilePool;
+
+    static ImageCache() => Crypto = SHA1.Create();
+
+    public ImageCache(
+        ILocalFileSystem localFileSystem,
+        IMemoryCache memoryCache,
+        ITempFilePool tempFilePool,
+        ILogger<ImageCache> logger)
     {
-        private static readonly SHA1 Crypto;
-        private readonly ILocalFileSystem _localFileSystem;
-        private readonly ILogger<ImageCache> _logger;
-        private readonly IMemoryCache _memoryCache;
-        private readonly ITempFilePool _tempFilePool;
+        _localFileSystem = localFileSystem;
+        _memoryCache = memoryCache;
+        _tempFilePool = tempFilePool;
+        _logger = logger;
+    }
 
-        static ImageCache() => Crypto = SHA1.Create();
+    public async Task<Either<BaseError, byte[]>> ResizeImage(byte[] imageBuffer, int height)
+    {
+        await using var inStream = new MemoryStream(imageBuffer);
+        using Image image = await Image.LoadAsync(inStream);
 
-        public ImageCache(
-            ILocalFileSystem localFileSystem,
-            IMemoryCache memoryCache,
-            ITempFilePool tempFilePool,
-            ILogger<ImageCache> logger)
-        {
-            _localFileSystem = localFileSystem;
-            _memoryCache = memoryCache;
-            _tempFilePool = tempFilePool;
-            _logger = logger;
-        }
+        var size = new Size { Height = height };
 
-        public async Task<Either<BaseError, byte[]>> ResizeImage(byte[] imageBuffer, int height)
-        {
-            await using var inStream = new MemoryStream(imageBuffer);
-            using Image image = await Image.LoadAsync(inStream);
-
-            var size = new Size { Height = height };
-
-            image.Mutate(
-                i => i.Resize(
-                    new ResizeOptions
-                    {
-                        Mode = ResizeMode.Max,
-                        Size = size
-                    }));
-
-            await using var outStream = new MemoryStream();
-            await image.SaveAsync(outStream, new JpegEncoder { Quality = 90 });
-
-            return outStream.ToArray();
-        }
-
-        public async Task<Either<BaseError, string>> SaveArtworkToCache(Stream stream, ArtworkKind artworkKind)
-        {
-            try
-            {
-                string tempFileName = _tempFilePool.GetNextTempFile(TempFileCategory.CachedArtwork);
-                // ReSharper disable once UseAwaitUsing
-                using (var fs = new FileStream(tempFileName, FileMode.OpenOrCreate, FileAccess.Write))
+        image.Mutate(
+            i => i.Resize(
+                new ResizeOptions
                 {
-                    await stream.CopyToAsync(fs);
-                }
-                byte[] hash = await ComputeFileHash(tempFileName);
-                string hex = BitConverter.ToString(hash).Replace("-", string.Empty);
-                string subfolder = hex[..2];
-                string baseFolder = artworkKind switch
-                {
-                    ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
-                    ArtworkKind.Thumbnail => Path.Combine(FileSystemLayout.ThumbnailCacheFolder, subfolder),
-                    ArtworkKind.Logo => Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder),
-                    ArtworkKind.FanArt => Path.Combine(FileSystemLayout.FanArtCacheFolder, subfolder),
-                    ArtworkKind.Watermark => Path.Combine(FileSystemLayout.WatermarkCacheFolder, subfolder),
-                    _ => FileSystemLayout.LegacyImageCacheFolder
-                };
-                string target = Path.Combine(baseFolder, hex);
+                    Mode = ResizeMode.Max,
+                    Size = size
+                }));
 
-                if (!Directory.Exists(baseFolder))
-                {
-                    Directory.CreateDirectory(baseFolder);
-                }
+        await using var outStream = new MemoryStream();
+        await image.SaveAsync(outStream, new JpegEncoder { Quality = 90 });
 
-                await _localFileSystem.CopyFile(tempFileName, target);
+        return outStream.ToArray();
+    }
 
-                return hex;
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        private static async Task<byte[]> ComputeFileHash(string fileName)
+    public async Task<Either<BaseError, string>> SaveArtworkToCache(Stream stream, ArtworkKind artworkKind)
+    {
+        try
         {
-            using var md5 = MD5.Create();
+            string tempFileName = _tempFilePool.GetNextTempFile(TempFileCategory.CachedArtwork);
             // ReSharper disable once UseAwaitUsing
-            // ReSharper disable once ConvertToUsingDeclaration
-            using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
+            using (var fs = new FileStream(tempFileName, FileMode.OpenOrCreate, FileAccess.Write))
             {
-                fs.Position = 0;
-                return await md5.ComputeHashAsync(fs);
+                await stream.CopyToAsync(fs);
             }
-        }
-
-        public async Task<Either<BaseError, string>> CopyArtworkToCache(string path, ArtworkKind artworkKind)
-        {
-            try
-            {
-                var filenameKey = $"{path}:{_localFileSystem.GetLastWriteTime(path).ToFileTimeUtc()}";
-                byte[] hash = Crypto.ComputeHash(Encoding.UTF8.GetBytes(filenameKey));
-                string hex = BitConverter.ToString(hash).Replace("-", string.Empty);
-                string subfolder = hex[..2];
-                string baseFolder = artworkKind switch
-                {
-                    ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
-                    ArtworkKind.Thumbnail => Path.Combine(FileSystemLayout.ThumbnailCacheFolder, subfolder),
-                    ArtworkKind.Logo => Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder),
-                    ArtworkKind.FanArt => Path.Combine(FileSystemLayout.FanArtCacheFolder, subfolder),
-                    _ => FileSystemLayout.LegacyImageCacheFolder
-                };
-                string target = Path.Combine(baseFolder, hex);
-                Either<BaseError, Unit> maybeResult = await _localFileSystem.CopyFile(path, target);
-                return maybeResult.Match<Either<BaseError, string>>(
-                    _ => hex,
-                    error => error);
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public string GetPathForImage(string fileName, ArtworkKind artworkKind, Option<int> maybeMaxHeight)
-        {
-            string subfolder = maybeMaxHeight.Match(
-                maxHeight => Path.Combine(maxHeight.ToString(), fileName[..2]),
-                () => fileName[..2]);
-
+            byte[] hash = await ComputeFileHash(tempFileName);
+            string hex = BitConverter.ToString(hash).Replace("-", string.Empty);
+            string subfolder = hex[..2];
             string baseFolder = artworkKind switch
             {
                 ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
@@ -156,58 +80,129 @@ namespace ErsatzTV.Infrastructure.Images
                 ArtworkKind.Watermark => Path.Combine(FileSystemLayout.WatermarkCacheFolder, subfolder),
                 _ => FileSystemLayout.LegacyImageCacheFolder
             };
+            string target = Path.Combine(baseFolder, hex);
 
-            return Path.Combine(baseFolder, fileName);
-        }
-
-        public async Task<bool> IsAnimated(string fileName)
-        {
-            try
+            if (!Directory.Exists(baseFolder))
             {
-                var cacheKey = $"image.animated.{Path.GetFileName(fileName)}";
-                if (_memoryCache.TryGetValue(cacheKey, out bool animated))
-                {
-                    return animated;
-                }
-
-                using Image image = await Image.LoadAsync(fileName);
-                animated = image.Frames.Count > 1;
-                _memoryCache.Set(cacheKey, animated, TimeSpan.FromDays(1));
-
-                return animated;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Unable to check image for animation");
-                return false;
-            }
-        }
-
-        public async Task<string> CalculateBlurHash(string fileName, ArtworkKind artworkKind, int x, int y)
-        {
-            var encoder = new Blurhash.ImageSharp.Encoder();
-            string targetFile = GetPathForImage(fileName, artworkKind, Option<int>.None);
-            await using var fs = new FileStream(targetFile, FileMode.Open, FileAccess.Read);
-            using var image = await Image.LoadAsync<Rgb24>(fs);
-            return encoder.Encode(image, x, y);
-        }
-
-        public async Task<string> WriteBlurHash(string blurHash, IDisplaySize targetSize)
-        {
-            byte[] bytes = Encoding.UTF8.GetBytes(blurHash);
-            string base64 = Convert.ToBase64String(bytes).Replace("+", "_").Replace("/", "-").Replace("=", "");
-            string targetFile = GetPathForImage(base64, ArtworkKind.Poster, targetSize.Height);
-            if (!_localFileSystem.FileExists(targetFile))
-            {
-                string folder = Path.GetDirectoryName(targetFile);
-                _localFileSystem.EnsureFolderExists(folder);
-                
-                var decoder = new Blurhash.ImageSharp.Decoder();
-                using Image<Rgb24> image = decoder.Decode(blurHash, targetSize.Width, targetSize.Height);
-                await image.SaveAsPngAsync(targetFile);
+                Directory.CreateDirectory(baseFolder);
             }
 
-            return targetFile;
+            await _localFileSystem.CopyFile(tempFileName, target);
+
+            return hex;
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.Message);
         }
     }
-}
+
+    private static async Task<byte[]> ComputeFileHash(string fileName)
+    {
+        using var md5 = MD5.Create();
+        // ReSharper disable once UseAwaitUsing
+        // ReSharper disable once ConvertToUsingDeclaration
+        using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
+        {
+            fs.Position = 0;
+            return await md5.ComputeHashAsync(fs);
+        }
+    }
+
+    public async Task<Either<BaseError, string>> CopyArtworkToCache(string path, ArtworkKind artworkKind)
+    {
+        try
+        {
+            var filenameKey = $"{path}:{_localFileSystem.GetLastWriteTime(path).ToFileTimeUtc()}";
+            byte[] hash = Crypto.ComputeHash(Encoding.UTF8.GetBytes(filenameKey));
+            string hex = BitConverter.ToString(hash).Replace("-", string.Empty);
+            string subfolder = hex[..2];
+            string baseFolder = artworkKind switch
+            {
+                ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
+                ArtworkKind.Thumbnail => Path.Combine(FileSystemLayout.ThumbnailCacheFolder, subfolder),
+                ArtworkKind.Logo => Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder),
+                ArtworkKind.FanArt => Path.Combine(FileSystemLayout.FanArtCacheFolder, subfolder),
+                _ => FileSystemLayout.LegacyImageCacheFolder
+            };
+            string target = Path.Combine(baseFolder, hex);
+            Either<BaseError, Unit> maybeResult = await _localFileSystem.CopyFile(path, target);
+            return maybeResult.Match<Either<BaseError, string>>(
+                _ => hex,
+                error => error);
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public string GetPathForImage(string fileName, ArtworkKind artworkKind, Option<int> maybeMaxHeight)
+    {
+        string subfolder = maybeMaxHeight.Match(
+            maxHeight => Path.Combine(maxHeight.ToString(), fileName[..2]),
+            () => fileName[..2]);
+
+        string baseFolder = artworkKind switch
+        {
+            ArtworkKind.Poster => Path.Combine(FileSystemLayout.PosterCacheFolder, subfolder),
+            ArtworkKind.Thumbnail => Path.Combine(FileSystemLayout.ThumbnailCacheFolder, subfolder),
+            ArtworkKind.Logo => Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder),
+            ArtworkKind.FanArt => Path.Combine(FileSystemLayout.FanArtCacheFolder, subfolder),
+            ArtworkKind.Watermark => Path.Combine(FileSystemLayout.WatermarkCacheFolder, subfolder),
+            _ => FileSystemLayout.LegacyImageCacheFolder
+        };
+
+        return Path.Combine(baseFolder, fileName);
+    }
+
+    public async Task<bool> IsAnimated(string fileName)
+    {
+        try
+        {
+            var cacheKey = $"image.animated.{Path.GetFileName(fileName)}";
+            if (_memoryCache.TryGetValue(cacheKey, out bool animated))
+            {
+                return animated;
+            }
+
+            using Image image = await Image.LoadAsync(fileName);
+            animated = image.Frames.Count > 1;
+            _memoryCache.Set(cacheKey, animated, TimeSpan.FromDays(1));
+
+            return animated;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Unable to check image for animation");
+            return false;
+        }
+    }
+
+    public async Task<string> CalculateBlurHash(string fileName, ArtworkKind artworkKind, int x, int y)
+    {
+        var encoder = new Blurhash.ImageSharp.Encoder();
+        string targetFile = GetPathForImage(fileName, artworkKind, Option<int>.None);
+        await using var fs = new FileStream(targetFile, FileMode.Open, FileAccess.Read);
+        using var image = await Image.LoadAsync<Rgb24>(fs);
+        return encoder.Encode(image, x, y);
+    }
+
+    public async Task<string> WriteBlurHash(string blurHash, IDisplaySize targetSize)
+    {
+        byte[] bytes = Encoding.UTF8.GetBytes(blurHash);
+        string base64 = Convert.ToBase64String(bytes).Replace("+", "_").Replace("/", "-").Replace("=", "");
+        string targetFile = GetPathForImage(base64, ArtworkKind.Poster, targetSize.Height);
+        if (!_localFileSystem.FileExists(targetFile))
+        {
+            string folder = Path.GetDirectoryName(targetFile);
+            _localFileSystem.EnsureFolderExists(folder);
+                
+            var decoder = new Blurhash.ImageSharp.Decoder();
+            using Image<Rgb24> image = decoder.Decode(blurHash, targetSize.Width, targetSize.Height);
+            await image.SaveAsPngAsync(targetFile);
+        }
+
+        return targetFile;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs b/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs
index ba2a5d63a..7e8b46ab8 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs
@@ -1,90 +1,86 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Jellyfin.Models;
+using ErsatzTV.Infrastructure.Jellyfin.Models;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.Jellyfin
+namespace ErsatzTV.Infrastructure.Jellyfin;
+
+[Headers("Accept: application/json")]
+public interface IJellyfinApi
 {
-    [Headers("Accept: application/json")]
-    public interface IJellyfinApi
-    {
-        [Get("/System/Info")]
-        public Task<JellyfinSystemInformationResponse> GetSystemInformation(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            CancellationToken cancellationToken);
+    [Get("/System/Info")]
+    public Task<JellyfinSystemInformationResponse> GetSystemInformation(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        CancellationToken cancellationToken);
 
-        [Get("/Users")]
-        public Task<List<JellyfinUserResponse>> GetUsers(
-            [Header("X-Emby-Token")]
-            string apiKey);
+    [Get("/Users")]
+    public Task<List<JellyfinUserResponse>> GetUsers(
+        [Header("X-Emby-Token")]
+        string apiKey);
 
-        [Get("/Library/VirtualFolders")]
-        public Task<List<JellyfinLibraryResponse>> GetLibraries(
-            [Header("X-Emby-Token")]
-            string apiKey);
+    [Get("/Library/VirtualFolders")]
+    public Task<List<JellyfinLibraryResponse>> GetLibraries(
+        [Header("X-Emby-Token")]
+        string apiKey);
 
-        [Get("/Items")]
-        public Task<JellyfinLibraryItemsResponse> GetMovieLibraryItems(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            [Query]
-            string userId,
-            [Query]
-            string parentId,
-            [Query]
-            string fields =
-                "Path,Genres,Tags,DateCreated,Etag,Overview,Taglines,Studios,People,OfficialRating,ProviderIds",
-            [Query]
-            string includeItemTypes = "Movie",
-            [Query]
-            bool recursive = true);
+    [Get("/Items")]
+    public Task<JellyfinLibraryItemsResponse> GetMovieLibraryItems(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string userId,
+        [Query]
+        string parentId,
+        [Query]
+        string fields =
+            "Path,Genres,Tags,DateCreated,Etag,Overview,Taglines,Studios,People,OfficialRating,ProviderIds",
+        [Query]
+        string includeItemTypes = "Movie",
+        [Query]
+        bool recursive = true);
 
-        [Get("/Items")]
-        public Task<JellyfinLibraryItemsResponse> GetShowLibraryItems(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            [Query]
-            string userId,
-            [Query]
-            string parentId,
-            [Query]
-            string fields =
-                "Path,Genres,Tags,DateCreated,Etag,Overview,Taglines,Studios,People,OfficialRating,ProviderIds",
-            [Query]
-            string includeItemTypes = "Series",
-            [Query]
-            bool recursive = true);
+    [Get("/Items")]
+    public Task<JellyfinLibraryItemsResponse> GetShowLibraryItems(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string userId,
+        [Query]
+        string parentId,
+        [Query]
+        string fields =
+            "Path,Genres,Tags,DateCreated,Etag,Overview,Taglines,Studios,People,OfficialRating,ProviderIds",
+        [Query]
+        string includeItemTypes = "Series",
+        [Query]
+        bool recursive = true);
 
-        [Get("/Items")]
-        public Task<JellyfinLibraryItemsResponse> GetSeasonLibraryItems(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            [Query]
-            string userId,
-            [Query]
-            string parentId,
-            [Query]
-            string fields = "Path,DateCreated,Etag,Taglines,ProviderIds",
-            [Query]
-            string includeItemTypes = "Season",
-            [Query]
-            bool recursive = true);
+    [Get("/Items")]
+    public Task<JellyfinLibraryItemsResponse> GetSeasonLibraryItems(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string userId,
+        [Query]
+        string parentId,
+        [Query]
+        string fields = "Path,DateCreated,Etag,Taglines,ProviderIds",
+        [Query]
+        string includeItemTypes = "Season",
+        [Query]
+        bool recursive = true);
 
-        [Get("/Items")]
-        public Task<JellyfinLibraryItemsResponse> GetEpisodeLibraryItems(
-            [Header("X-Emby-Token")]
-            string apiKey,
-            [Query]
-            string userId,
-            [Query]
-            string parentId,
-            [Query]
-            string fields = "Path,DateCreated,Etag,Overview,ProviderIds,People",
-            [Query]
-            string includeItemTypes = "Episode",
-            [Query]
-            bool recursive = true);
-    }
-}
+    [Get("/Items")]
+    public Task<JellyfinLibraryItemsResponse> GetEpisodeLibraryItems(
+        [Header("X-Emby-Token")]
+        string apiKey,
+        [Query]
+        string userId,
+        [Query]
+        string parentId,
+        [Query]
+        string fields = "Path,DateCreated,Etag,Overview,ProviderIds,People",
+        [Query]
+        string includeItemTypes = "Episode",
+        [Query]
+        bool recursive = true);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs b/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs
index 0b57c75d6..c58f935a1 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs
@@ -1,318 +1,487 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Jellyfin;
 using ErsatzTV.Infrastructure.Jellyfin.Models;
-using LanguageExt;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Refit;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Jellyfin
+namespace ErsatzTV.Infrastructure.Jellyfin;
+
+public class JellyfinApiClient : IJellyfinApiClient
 {
-    public class JellyfinApiClient : IJellyfinApiClient
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
+    private readonly ILogger<JellyfinApiClient> _logger;
+    private readonly IMemoryCache _memoryCache;
+
+    public JellyfinApiClient(
+        IMemoryCache memoryCache,
+        IFallbackMetadataProvider fallbackMetadataProvider,
+        ILogger<JellyfinApiClient> logger)
     {
-        private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
-        private readonly ILogger<JellyfinApiClient> _logger;
-        private readonly IMemoryCache _memoryCache;
+        _memoryCache = memoryCache;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
+        _logger = logger;
+    }
 
-        public JellyfinApiClient(
-            IMemoryCache memoryCache,
-            IFallbackMetadataProvider fallbackMetadataProvider,
-            ILogger<JellyfinApiClient> logger)
+    public async Task<Either<BaseError, JellyfinServerInformation>> GetServerInformation(
+        string address,
+        string apiKey)
+    {
+        try
         {
-            _memoryCache = memoryCache;
-            _fallbackMetadataProvider = fallbackMetadataProvider;
-            _logger = logger;
+            IJellyfinApi service = RestService.For<IJellyfinApi>(address);
+            var cts = new CancellationTokenSource();
+            cts.CancelAfter(TimeSpan.FromSeconds(5));
+            return await service.GetSystemInformation(apiKey, cts.Token)
+                .Map(response => new JellyfinServerInformation(response.ServerName, response.OperatingSystem));
         }
-
-        public async Task<Either<BaseError, JellyfinServerInformation>> GetServerInformation(
-            string address,
-            string apiKey)
+        catch (OperationCanceledException ex)
         {
-            try
+            _logger.LogError(ex, "Timeout getting jellyfin server name");
+            return BaseError.New("Jellyfin did not respond in time");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting jellyfin server name");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    public async Task<Either<BaseError, List<JellyfinLibrary>>> GetLibraries(string address, string apiKey)
+    {
+        try
+        {
+            IJellyfinApi service = RestService.For<IJellyfinApi>(address);
+            List<JellyfinLibraryResponse> libraries = await service.GetLibraries(apiKey);
+            return libraries
+                .Map(Project)
+                .Somes()
+                .ToList();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting jellyfin libraries");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    public async Task<Either<BaseError, string>> GetAdminUserId(string address, string apiKey)
+    {
+        try
+        {
+            IJellyfinApi service = RestService.For<IJellyfinApi>(address);
+            List<JellyfinUserResponse> users = await service.GetUsers(apiKey);
+            Option<string> maybeUserId = users
+                .Filter(user => user.Policy.IsAdministrator)
+                .Map(user => user.Id)
+                .HeadOrNone();
+
+            return maybeUserId.ToEither(BaseError.New("Unable to locate jellyfin admin user"));
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting jellyfin admin user id");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    public async Task<Either<BaseError, List<JellyfinMovie>>> GetMovieLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string libraryId)
+    {
+        try
+        {
+            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
             {
                 IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                var cts = new CancellationTokenSource();
-                cts.CancelAfter(TimeSpan.FromSeconds(5));
-                return await service.GetSystemInformation(apiKey, cts.Token)
-                    .Map(response => new JellyfinServerInformation(response.ServerName, response.OperatingSystem));
-            }
-            catch (OperationCanceledException ex)
-            {
-                _logger.LogError(ex, "Timeout getting jellyfin server name");
-                return BaseError.New("Jellyfin did not respond in time");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting jellyfin server name");
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        public async Task<Either<BaseError, List<JellyfinLibrary>>> GetLibraries(string address, string apiKey)
-        {
-            try
-            {
-                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                List<JellyfinLibraryResponse> libraries = await service.GetLibraries(apiKey);
-                return libraries
-                    .Map(Project)
+                JellyfinLibraryItemsResponse items = await service.GetMovieLibraryItems(apiKey, userId, libraryId);
+                return items.Items
+                    .Map(ProjectToMovie)
                     .Somes()
                     .ToList();
             }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting jellyfin libraries");
-                return BaseError.New(ex.Message);
-            }
-        }
 
-        public async Task<Either<BaseError, string>> GetAdminUserId(string address, string apiKey)
+            return BaseError.New("Jellyfin admin user id is not available");
+        }
+        catch (Exception ex)
         {
-            try
+            _logger.LogError(ex, "Error getting jellyfin movie library items");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    public async Task<Either<BaseError, List<JellyfinShow>>> GetShowLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string libraryId)
+    {
+        try
+        {
+            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
             {
                 IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                List<JellyfinUserResponse> users = await service.GetUsers(apiKey);
-                Option<string> maybeUserId = users
-                    .Filter(user => user.Policy.IsAdministrator)
-                    .Map(user => user.Id)
-                    .HeadOrNone();
+                JellyfinLibraryItemsResponse items = await service.GetShowLibraryItems(apiKey, userId, libraryId);
+                return items.Items
+                    .Map(ProjectToShow)
+                    .Somes()
+                    .ToList();
+            }
 
-                return maybeUserId.ToEither(BaseError.New("Unable to locate jellyfin admin user"));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting jellyfin admin user id");
-                return BaseError.New(ex.Message);
-            }
+            return BaseError.New("Jellyfin admin user id is not available");
         }
-
-        public async Task<Either<BaseError, List<JellyfinMovie>>> GetMovieLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string libraryId)
+        catch (Exception ex)
         {
-            try
-            {
-                if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
-                {
-                    IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                    JellyfinLibraryItemsResponse items = await service.GetMovieLibraryItems(apiKey, userId, libraryId);
-                    return items.Items
-                        .Map(ProjectToMovie)
-                        .Somes()
-                        .ToList();
-                }
-
-                return BaseError.New("Jellyfin admin user id is not available");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting jellyfin movie library items");
-                return BaseError.New(ex.Message);
-            }
+            _logger.LogError(ex, "Error getting jellyfin show library items");
+            return BaseError.New(ex.Message);
         }
+    }
 
-        public async Task<Either<BaseError, List<JellyfinShow>>> GetShowLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string libraryId)
+    public async Task<Either<BaseError, List<JellyfinSeason>>> GetSeasonLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string showId)
+    {
+        try
         {
-            try
+            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
             {
-                if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
-                {
-                    IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                    JellyfinLibraryItemsResponse items = await service.GetShowLibraryItems(apiKey, userId, libraryId);
-                    return items.Items
-                        .Map(ProjectToShow)
-                        .Somes()
-                        .ToList();
-                }
+                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
+                JellyfinLibraryItemsResponse items = await service.GetSeasonLibraryItems(apiKey, userId, showId);
+                return items.Items
+                    .Map(ProjectToSeason)
+                    .Somes()
+                    .ToList();
+            }
 
-                return BaseError.New("Jellyfin admin user id is not available");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting jellyfin show library items");
-                return BaseError.New(ex.Message);
-            }
+            return BaseError.New("Jellyfin admin user id is not available");
         }
-
-        public async Task<Either<BaseError, List<JellyfinSeason>>> GetSeasonLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string showId)
+        catch (Exception ex)
         {
-            try
-            {
-                if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
-                {
-                    IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                    JellyfinLibraryItemsResponse items = await service.GetSeasonLibraryItems(apiKey, userId, showId);
-                    return items.Items
-                        .Map(ProjectToSeason)
-                        .Somes()
-                        .ToList();
-                }
-
-                return BaseError.New("Jellyfin admin user id is not available");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting jellyfin show library items");
-                return BaseError.New(ex.Message);
-            }
+            _logger.LogError(ex, "Error getting jellyfin show library items");
+            return BaseError.New(ex.Message);
         }
+    }
 
-        public async Task<Either<BaseError, List<JellyfinEpisode>>> GetEpisodeLibraryItems(
-            string address,
-            string apiKey,
-            int mediaSourceId,
-            string seasonId)
+    public async Task<Either<BaseError, List<JellyfinEpisode>>> GetEpisodeLibraryItems(
+        string address,
+        string apiKey,
+        int mediaSourceId,
+        string seasonId)
+    {
+        try
         {
-            try
+            if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
             {
-                if (_memoryCache.TryGetValue($"jellyfin_admin_user_id.{mediaSourceId}", out string userId))
-                {
-                    IJellyfinApi service = RestService.For<IJellyfinApi>(address);
-                    JellyfinLibraryItemsResponse items = await service.GetEpisodeLibraryItems(apiKey, userId, seasonId);
-                    return items.Items
-                        .Map(ProjectToEpisode)
-                        .Somes()
-                        .ToList();
-                }
+                IJellyfinApi service = RestService.For<IJellyfinApi>(address);
+                JellyfinLibraryItemsResponse items = await service.GetEpisodeLibraryItems(apiKey, userId, seasonId);
+                return items.Items
+                    .Map(ProjectToEpisode)
+                    .Somes()
+                    .ToList();
+            }
 
-                return BaseError.New("Jellyfin admin user id is not available");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting jellyfin episode library items");
-                return BaseError.New(ex.Message);
-            }
+            return BaseError.New("Jellyfin admin user id is not available");
         }
-
-        private static Option<JellyfinLibrary> Project(JellyfinLibraryResponse response) =>
-            response.CollectionType?.ToLowerInvariant() switch
-            {
-                "tvshows" => new JellyfinLibrary
-                {
-                    ItemId = response.ItemId,
-                    Name = response.Name,
-                    MediaKind = LibraryMediaKind.Shows,
-                    ShouldSyncItems = false,
-                    Paths = new List<LibraryPath> { new() { Path = $"jellyfin://{response.ItemId}" } }
-                },
-                "movies" => new JellyfinLibrary
-                {
-                    ItemId = response.ItemId,
-                    Name = response.Name,
-                    MediaKind = LibraryMediaKind.Movies,
-                    ShouldSyncItems = false,
-                    Paths = new List<LibraryPath> { new() { Path = $"jellyfin://{response.ItemId}" } }
-                },
-                // TODO: ??? for music libraries
-                _ => None
-            };
-
-        private Option<JellyfinMovie> ProjectToMovie(JellyfinLibraryItemResponse item)
+        catch (Exception ex)
         {
-            try
+            _logger.LogError(ex, "Error getting jellyfin episode library items");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    private static Option<JellyfinLibrary> Project(JellyfinLibraryResponse response) =>
+        response.CollectionType?.ToLowerInvariant() switch
+        {
+            "tvshows" => new JellyfinLibrary
             {
-                if (item.LocationType != "FileSystem")
-                {
-                    return None;
-                }
-
-                if (Path.GetExtension(item.Path)?.ToLowerInvariant() == ".strm")
-                {
-                    _logger.LogInformation("STRM files are not supported; skipping {Path}", item.Path);
-                    return None;
-                }
-
-                var version = new MediaVersion
-                {
-                    Name = "Main",
-                    Duration = TimeSpan.FromTicks(item.RunTimeTicks),
-                    DateAdded = item.DateCreated.UtcDateTime,
-                    MediaFiles = new List<MediaFile>
-                    {
-                        new()
-                        {
-                            Path = item.Path
-                        }
-                    },
-                    Streams = new List<MediaStream>()
-                };
-
-                MovieMetadata metadata = ProjectToMovieMetadata(item);
-
-                var movie = new JellyfinMovie
-                {
-                    ItemId = item.Id,
-                    Etag = item.Etag,
-                    MediaVersions = new List<MediaVersion> { version },
-                    MovieMetadata = new List<MovieMetadata> { metadata },
-                    TraktListItems = new List<TraktListItem>()
-                };
-
-                return movie;
-            }
-            catch (Exception ex)
+                ItemId = response.ItemId,
+                Name = response.Name,
+                MediaKind = LibraryMediaKind.Shows,
+                ShouldSyncItems = false,
+                Paths = new List<LibraryPath> { new() { Path = $"jellyfin://{response.ItemId}" } }
+            },
+            "movies" => new JellyfinLibrary
+            {
+                ItemId = response.ItemId,
+                Name = response.Name,
+                MediaKind = LibraryMediaKind.Movies,
+                ShouldSyncItems = false,
+                Paths = new List<LibraryPath> { new() { Path = $"jellyfin://{response.ItemId}" } }
+            },
+            // TODO: ??? for music libraries
+            _ => None
+        };
+
+    private Option<JellyfinMovie> ProjectToMovie(JellyfinLibraryItemResponse item)
+    {
+        try
+        {
+            if (item.LocationType != "FileSystem")
             {
-                _logger.LogWarning(ex, "Error projecting Jellyfin movie");
                 return None;
             }
+
+            if (Path.GetExtension(item.Path)?.ToLowerInvariant() == ".strm")
+            {
+                _logger.LogInformation("STRM files are not supported; skipping {Path}", item.Path);
+                return None;
+            }
+
+            var version = new MediaVersion
+            {
+                Name = "Main",
+                Duration = TimeSpan.FromTicks(item.RunTimeTicks),
+                DateAdded = item.DateCreated.UtcDateTime,
+                MediaFiles = new List<MediaFile>
+                {
+                    new()
+                    {
+                        Path = item.Path
+                    }
+                },
+                Streams = new List<MediaStream>()
+            };
+
+            MovieMetadata metadata = ProjectToMovieMetadata(item);
+
+            var movie = new JellyfinMovie
+            {
+                ItemId = item.Id,
+                Etag = item.Etag,
+                MediaVersions = new List<MediaVersion> { version },
+                MovieMetadata = new List<MovieMetadata> { metadata },
+                TraktListItems = new List<TraktListItem>()
+            };
+
+            return movie;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error projecting Jellyfin movie");
+            return None;
+        }
+    }
+
+    private MovieMetadata ProjectToMovieMetadata(JellyfinLibraryItemResponse item)
+    {
+        DateTime dateAdded = item.DateCreated.UtcDateTime;
+        // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
+
+        var metadata = new MovieMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = item.Name,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
+            Plot = item.Overview,
+            Year = item.ProductionYear,
+            Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
+            DateAdded = dateAdded,
+            ContentRating = item.OfficialRating,
+            Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
+            Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
+            Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
+            Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
+            Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
+            Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList(),
+            Artwork = new List<Artwork>(),
+            Guids = GuidsFromProviderIds(item.ProviderIds)
+        };
+
+        // set order on actors
+        for (var i = 0; i < metadata.Actors.Count; i++)
+        {
+            metadata.Actors[i].Order = i;
         }
 
-        private MovieMetadata ProjectToMovieMetadata(JellyfinLibraryItemResponse item)
+        if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
+        {
+            metadata.ReleaseDate = releaseDate;
+        }
+
+        if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
+        {
+            var poster = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Poster,
+                Path = $"jellyfin://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(poster);
+        }
+
+        if (item.BackdropImageTags.Any())
+        {
+            var fanArt = new Artwork
+            {
+                ArtworkKind = ArtworkKind.FanArt,
+                Path = $"jellyfin://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(fanArt);
+        }
+
+        return metadata;
+    }
+
+    private static Option<Actor> ProjectToActor(JellyfinPersonResponse person, DateTime dateAdded)
+    {
+        if (person.Type?.ToLowerInvariant() != "actor")
+        {
+            return None;
+        }
+
+        var actor = new Actor { Name = person.Name, Role = person.Role };
+        if (!string.IsNullOrWhiteSpace(person.Id) && !string.IsNullOrWhiteSpace(person.PrimaryImageTag))
+        {
+            actor.Artwork = new Artwork
+            {
+                Path = $"jellyfin://Items/{person.Id}/Images/Primary?tag={person.PrimaryImageTag}",
+                ArtworkKind = ArtworkKind.Thumbnail,
+                DateAdded = dateAdded
+            };
+        }
+
+        return actor;
+    }
+
+    private static Option<Director> ProjectToDirector(JellyfinPersonResponse person)
+    {
+        if (person.Type?.ToLowerInvariant() != "director")
+        {
+            return None;
+        }
+
+        return new Director { Name = person.Name };
+    }
+
+    private static Option<Writer> ProjectToWriter(JellyfinPersonResponse person)
+    {
+        if (person.Type?.ToLowerInvariant() != "writer")
+        {
+            return None;
+        }
+
+        return new Writer { Name = person.Name };
+    }
+
+    private Option<JellyfinShow> ProjectToShow(JellyfinLibraryItemResponse item)
+    {
+        try
+        {
+            ShowMetadata metadata = ProjectToShowMetadata(item);
+
+            var show = new JellyfinShow
+            {
+                ItemId = item.Id,
+                Etag = item.Etag,
+                ShowMetadata = new List<ShowMetadata> { metadata },
+                TraktListItems = new List<TraktListItem>()
+            };
+
+            return show;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error projecting Jellyfin show");
+            return None;
+        }
+    }
+
+    private ShowMetadata ProjectToShowMetadata(JellyfinLibraryItemResponse item)
+    {
+        DateTime dateAdded = item.DateCreated.UtcDateTime;
+        // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
+
+        var metadata = new ShowMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = item.Name,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
+            Plot = item.Overview,
+            Year = item.ProductionYear,
+            Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
+            DateAdded = dateAdded,
+            ContentRating = item.OfficialRating,
+            Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
+            Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
+            Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
+            Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
+            Artwork = new List<Artwork>(),
+            Guids = GuidsFromProviderIds(item.ProviderIds)
+        };
+
+        // set order on actors
+        for (var i = 0; i < metadata.Actors.Count; i++)
+        {
+            metadata.Actors[i].Order = i;
+        }
+
+        if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
+        {
+            metadata.ReleaseDate = releaseDate;
+        }
+
+        if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
+        {
+            var poster = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Poster,
+                Path = $"jellyfin://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(poster);
+        }
+
+        if (!string.IsNullOrWhiteSpace(item.ImageTags.Thumb))
+        {
+            var thumb = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Thumbnail,
+                Path = $"jellyfin://Items/{item.Id}/Images/Thumb?tag={item.ImageTags.Thumb}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(thumb);
+        }
+
+        if (item.BackdropImageTags.Any())
+        {
+            var fanArt = new Artwork
+            {
+                ArtworkKind = ArtworkKind.FanArt,
+                Path = $"jellyfin://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(fanArt);
+        }
+
+        return metadata;
+    }
+
+    private Option<JellyfinSeason> ProjectToSeason(JellyfinLibraryItemResponse item)
+    {
+        try
         {
             DateTime dateAdded = item.DateCreated.UtcDateTime;
-            // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
+            // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
 
-            var metadata = new MovieMetadata
+            var metadata = new SeasonMetadata
             {
                 MetadataKind = MetadataKind.External,
                 Title = item.Name,
                 SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
-                Plot = item.Overview,
                 Year = item.ProductionYear,
-                Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
                 DateAdded = dateAdded,
-                ContentRating = item.OfficialRating,
-                Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
-                Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
-                Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
-                Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
-                Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
-                Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList(),
                 Artwork = new List<Artwork>(),
                 Guids = GuidsFromProviderIds(item.ProviderIds)
             };
 
-            // set order on actors
-            for (var i = 0; i < metadata.Actors.Count; i++)
-            {
-                metadata.Actors[i].Order = i;
-            }
-
-            if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
             if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
             {
                 var poster = new Artwork
@@ -335,325 +504,147 @@ namespace ErsatzTV.Infrastructure.Jellyfin
                 metadata.Artwork.Add(fanArt);
             }
 
-            return metadata;
-        }
-
-        private static Option<Actor> ProjectToActor(JellyfinPersonResponse person, DateTime dateAdded)
-        {
-            if (person.Type?.ToLowerInvariant() != "actor")
+            var season = new JellyfinSeason
             {
-                return None;
-            }
-
-            var actor = new Actor { Name = person.Name, Role = person.Role };
-            if (!string.IsNullOrWhiteSpace(person.Id) && !string.IsNullOrWhiteSpace(person.PrimaryImageTag))
-            {
-                actor.Artwork = new Artwork
-                {
-                    Path = $"jellyfin://Items/{person.Id}/Images/Primary?tag={person.PrimaryImageTag}",
-                    ArtworkKind = ArtworkKind.Thumbnail,
-                    DateAdded = dateAdded
-                };
-            }
-
-            return actor;
-        }
-
-        private static Option<Director> ProjectToDirector(JellyfinPersonResponse person)
-        {
-            if (person.Type?.ToLowerInvariant() != "director")
-            {
-                return None;
-            }
-
-            return new Director { Name = person.Name };
-        }
-
-        private static Option<Writer> ProjectToWriter(JellyfinPersonResponse person)
-        {
-            if (person.Type?.ToLowerInvariant() != "writer")
-            {
-                return None;
-            }
-
-            return new Writer { Name = person.Name };
-        }
-
-        private Option<JellyfinShow> ProjectToShow(JellyfinLibraryItemResponse item)
-        {
-            try
-            {
-                ShowMetadata metadata = ProjectToShowMetadata(item);
-
-                var show = new JellyfinShow
-                {
-                    ItemId = item.Id,
-                    Etag = item.Etag,
-                    ShowMetadata = new List<ShowMetadata> { metadata },
-                    TraktListItems = new List<TraktListItem>()
-                };
-
-                return show;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error projecting Jellyfin show");
-                return None;
-            }
-        }
-
-        private ShowMetadata ProjectToShowMetadata(JellyfinLibraryItemResponse item)
-        {
-            DateTime dateAdded = item.DateCreated.UtcDateTime;
-            // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
-
-            var metadata = new ShowMetadata
-            {
-                MetadataKind = MetadataKind.External,
-                Title = item.Name,
-                SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
-                Plot = item.Overview,
-                Year = item.ProductionYear,
-                Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
-                DateAdded = dateAdded,
-                ContentRating = item.OfficialRating,
-                Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
-                Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
-                Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
-                Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
-                Artwork = new List<Artwork>(),
-                Guids = GuidsFromProviderIds(item.ProviderIds)
-            };
-
-            // set order on actors
-            for (var i = 0; i < metadata.Actors.Count; i++)
-            {
-                metadata.Actors[i].Order = i;
-            }
-
-            if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
-            if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
-            {
-                var poster = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Poster,
-                    Path = $"jellyfin://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
-                    DateAdded = dateAdded
-                };
-                metadata.Artwork.Add(poster);
-            }
-
-            if (!string.IsNullOrWhiteSpace(item.ImageTags.Thumb))
-            {
-                var thumb = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Thumbnail,
-                    Path = $"jellyfin://Items/{item.Id}/Images/Thumb?tag={item.ImageTags.Thumb}",
-                    DateAdded = dateAdded
-                };
-                metadata.Artwork.Add(thumb);
-            }
-
-            if (item.BackdropImageTags.Any())
-            {
-                var fanArt = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.FanArt,
-                    Path = $"jellyfin://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
-                    DateAdded = dateAdded
-                };
-                metadata.Artwork.Add(fanArt);
-            }
-
-            return metadata;
-        }
-
-        private Option<JellyfinSeason> ProjectToSeason(JellyfinLibraryItemResponse item)
-        {
-            try
-            {
-                DateTime dateAdded = item.DateCreated.UtcDateTime;
-                // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
-
-                var metadata = new SeasonMetadata
-                {
-                    MetadataKind = MetadataKind.External,
-                    Title = item.Name,
-                    SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
-                    Year = item.ProductionYear,
-                    DateAdded = dateAdded,
-                    Artwork = new List<Artwork>(),
-                    Guids = GuidsFromProviderIds(item.ProviderIds)
-                };
-
-                if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
-                {
-                    var poster = new Artwork
-                    {
-                        ArtworkKind = ArtworkKind.Poster,
-                        Path = $"jellyfin://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
-                        DateAdded = dateAdded
-                    };
-                    metadata.Artwork.Add(poster);
-                }
-
-                if (item.BackdropImageTags.Any())
-                {
-                    var fanArt = new Artwork
-                    {
-                        ArtworkKind = ArtworkKind.FanArt,
-                        Path = $"jellyfin://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
-                        DateAdded = dateAdded
-                    };
-                    metadata.Artwork.Add(fanArt);
-                }
-
-                var season = new JellyfinSeason
-                {
-                    ItemId = item.Id,
-                    Etag = item.Etag,
-                    SeasonMetadata = new List<SeasonMetadata> { metadata },
-                    TraktListItems = new List<TraktListItem>()
-                };
-
-                if (item.IndexNumber.HasValue)
-                {
-                    season.SeasonNumber = item.IndexNumber.Value;
-                }
-
-                return season;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error projecting Jellyfin season");
-                return None;
-            }
-        }
-
-        private Option<JellyfinEpisode> ProjectToEpisode(JellyfinLibraryItemResponse item)
-        {
-            try
-            {
-                if (item.LocationType != "FileSystem")
-                {
-                    return None;
-                }
-
-                if (Path.GetExtension(item.Path)?.ToLowerInvariant() == ".strm")
-                {
-                    _logger.LogWarning("STRM files are not supported; skipping {Path}", item.Path);
-                    return None;
-                }
-
-                var version = new MediaVersion
-                {
-                    Name = "Main",
-                    Duration = TimeSpan.FromTicks(item.RunTimeTicks),
-                    DateAdded = item.DateCreated.UtcDateTime,
-                    MediaFiles = new List<MediaFile>
-                    {
-                        new()
-                        {
-                            Path = item.Path
-                        }
-                    },
-                    Streams = new List<MediaStream>()
-                };
-
-                EpisodeMetadata metadata = ProjectToEpisodeMetadata(item);
-
-                var episode = new JellyfinEpisode
-                {
-                    ItemId = item.Id,
-                    Etag = item.Etag,
-                    MediaVersions = new List<MediaVersion> { version },
-                    EpisodeMetadata = new List<EpisodeMetadata> { metadata },
-                    TraktListItems = new List<TraktListItem>()
-                };
-
-                return episode;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error projecting Jellyfin episode");
-                return None;
-            }
-        }
-
-        private EpisodeMetadata ProjectToEpisodeMetadata(JellyfinLibraryItemResponse item)
-        {
-            DateTime dateAdded = item.DateCreated.UtcDateTime;
-            // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
-
-            var metadata = new EpisodeMetadata
-            {
-                MetadataKind = MetadataKind.External,
-                Title = item.Name,
-                SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
-                Plot = item.Overview,
-                Year = item.ProductionYear,
-                DateAdded = dateAdded,
-                Genres = new List<Genre>(),
-                Tags = new List<Tag>(),
-                Studios = new List<Studio>(),
-                Actors = new List<Actor>(),
-                Artwork = new List<Artwork>(),
-                Guids = GuidsFromProviderIds(item.ProviderIds),
-                Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
-                Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList()
+                ItemId = item.Id,
+                Etag = item.Etag,
+                SeasonMetadata = new List<SeasonMetadata> { metadata },
+                TraktListItems = new List<TraktListItem>()
             };
 
             if (item.IndexNumber.HasValue)
             {
-                metadata.EpisodeNumber = item.IndexNumber.Value;
+                season.SeasonNumber = item.IndexNumber.Value;
             }
 
-            if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
-            if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
-            {
-                var thumbnail = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Thumbnail,
-                    Path = $"jellyfin://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
-                    DateAdded = dateAdded
-                };
-                metadata.Artwork.Add(thumbnail);
-            }
-
-            return metadata;
+            return season;
         }
-
-        private List<MetadataGuid> GuidsFromProviderIds(JellyfinProviderIdsResponse providerIds)
+        catch (Exception ex)
         {
-            var result = new List<MetadataGuid>();
-
-            if (providerIds != null)
-            {
-                if (!string.IsNullOrWhiteSpace(providerIds.Imdb))
-                {
-                    result.Add(new MetadataGuid { Guid = $"imdb://{providerIds.Imdb}" });
-                }
-
-                if (!string.IsNullOrWhiteSpace(providerIds.Tmdb))
-                {
-                    result.Add(new MetadataGuid { Guid = $"tmdb://{providerIds.Tmdb}" });
-                }
-
-                if (!string.IsNullOrWhiteSpace(providerIds.Tvdb))
-                {
-                    result.Add(new MetadataGuid { Guid = $"tvdb://{providerIds.Tvdb}" });
-                }
-            }
-
-            return result;
+            _logger.LogWarning(ex, "Error projecting Jellyfin season");
+            return None;
         }
     }
-}
+
+    private Option<JellyfinEpisode> ProjectToEpisode(JellyfinLibraryItemResponse item)
+    {
+        try
+        {
+            if (item.LocationType != "FileSystem")
+            {
+                return None;
+            }
+
+            if (Path.GetExtension(item.Path)?.ToLowerInvariant() == ".strm")
+            {
+                _logger.LogWarning("STRM files are not supported; skipping {Path}", item.Path);
+                return None;
+            }
+
+            var version = new MediaVersion
+            {
+                Name = "Main",
+                Duration = TimeSpan.FromTicks(item.RunTimeTicks),
+                DateAdded = item.DateCreated.UtcDateTime,
+                MediaFiles = new List<MediaFile>
+                {
+                    new()
+                    {
+                        Path = item.Path
+                    }
+                },
+                Streams = new List<MediaStream>()
+            };
+
+            EpisodeMetadata metadata = ProjectToEpisodeMetadata(item);
+
+            var episode = new JellyfinEpisode
+            {
+                ItemId = item.Id,
+                Etag = item.Etag,
+                MediaVersions = new List<MediaVersion> { version },
+                EpisodeMetadata = new List<EpisodeMetadata> { metadata },
+                TraktListItems = new List<TraktListItem>()
+            };
+
+            return episode;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error projecting Jellyfin episode");
+            return None;
+        }
+    }
+
+    private EpisodeMetadata ProjectToEpisodeMetadata(JellyfinLibraryItemResponse item)
+    {
+        DateTime dateAdded = item.DateCreated.UtcDateTime;
+        // DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
+
+        var metadata = new EpisodeMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = item.Name,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
+            Plot = item.Overview,
+            Year = item.ProductionYear,
+            DateAdded = dateAdded,
+            Genres = new List<Genre>(),
+            Tags = new List<Tag>(),
+            Studios = new List<Studio>(),
+            Actors = new List<Actor>(),
+            Artwork = new List<Artwork>(),
+            Guids = GuidsFromProviderIds(item.ProviderIds),
+            Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
+            Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList()
+        };
+
+        if (item.IndexNumber.HasValue)
+        {
+            metadata.EpisodeNumber = item.IndexNumber.Value;
+        }
+
+        if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
+        {
+            metadata.ReleaseDate = releaseDate;
+        }
+
+        if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
+        {
+            var thumbnail = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Thumbnail,
+                Path = $"jellyfin://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
+                DateAdded = dateAdded
+            };
+            metadata.Artwork.Add(thumbnail);
+        }
+
+        return metadata;
+    }
+
+    private List<MetadataGuid> GuidsFromProviderIds(JellyfinProviderIdsResponse providerIds)
+    {
+        var result = new List<MetadataGuid>();
+
+        if (providerIds != null)
+        {
+            if (!string.IsNullOrWhiteSpace(providerIds.Imdb))
+            {
+                result.Add(new MetadataGuid { Guid = $"imdb://{providerIds.Imdb}" });
+            }
+
+            if (!string.IsNullOrWhiteSpace(providerIds.Tmdb))
+            {
+                result.Add(new MetadataGuid { Guid = $"tmdb://{providerIds.Tmdb}" });
+            }
+
+            if (!string.IsNullOrWhiteSpace(providerIds.Tvdb))
+            {
+                result.Add(new MetadataGuid { Guid = $"tvdb://{providerIds.Tvdb}" });
+            }
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/JellyfinSecretStore.cs b/ErsatzTV.Infrastructure/Jellyfin/JellyfinSecretStore.cs
index 76a210edb..bb9f6e0c6 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/JellyfinSecretStore.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/JellyfinSecretStore.cs
@@ -1,26 +1,21 @@
-using System.IO;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Jellyfin;
 using ErsatzTV.Core.Jellyfin;
-using LanguageExt;
 using Newtonsoft.Json;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Jellyfin
+namespace ErsatzTV.Infrastructure.Jellyfin;
+
+public class JellyfinSecretStore : IJellyfinSecretStore
 {
-    public class JellyfinSecretStore : IJellyfinSecretStore
-    {
-        public Task<Unit> DeleteAll() => SaveSecrets(new JellyfinSecrets());
+    public Task<Unit> DeleteAll() => SaveSecrets(new JellyfinSecrets());
 
-        public Task<JellyfinSecrets> ReadSecrets() =>
-            File.ReadAllTextAsync(FileSystemLayout.JellyfinSecretsPath)
-                .Map(JsonConvert.DeserializeObject<JellyfinSecrets>)
-                .Map(s => Optional(s).IfNone(new JellyfinSecrets()));
+    public Task<JellyfinSecrets> ReadSecrets() =>
+        File.ReadAllTextAsync(FileSystemLayout.JellyfinSecretsPath)
+            .Map(JsonConvert.DeserializeObject<JellyfinSecrets>)
+            .Map(s => Optional(s).IfNone(new JellyfinSecrets()));
 
-        public Task<Unit> SaveSecrets(JellyfinSecrets jellyfinSecrets) =>
-            Some(JsonConvert.SerializeObject(jellyfinSecrets)).Match(
-                s => File.WriteAllTextAsync(FileSystemLayout.JellyfinSecretsPath, s).ToUnit(),
-                Task.FromResult(Unit.Default));
-    }
-}
+    public Task<Unit> SaveSecrets(JellyfinSecrets jellyfinSecrets) =>
+        Some(JsonConvert.SerializeObject(jellyfinSecrets)).Match(
+            s => File.WriteAllTextAsync(FileSystemLayout.JellyfinSecretsPath, s).ToUnit(),
+            Task.FromResult(Unit.Default));
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinImageTagsResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinImageTagsResponse.cs
index 7dc644e3b..2aadfcf44 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinImageTagsResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinImageTagsResponse.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinImageTagsResponse
 {
-    public class JellyfinImageTagsResponse
-    {
-        public string Primary { get; set; }
-        public string Thumb { get; set; }
-    }
-}
+    public string Primary { get; set; }
+    public string Thumb { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemResponse.cs
index 06fdf5a91..2d8f5f08c 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemResponse.cs
@@ -1,30 +1,26 @@
-using System;
-using System.Collections.Generic;
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
 
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+public class JellyfinLibraryItemResponse
 {
-    public class JellyfinLibraryItemResponse
-    {
-        public string Name { get; set; }
-        public string Id { get; set; }
-        public string Etag { get; set; }
-        public string Path { get; set; }
-        public string OfficialRating { get; set; }
-        public DateTimeOffset DateCreated { get; set; }
-        public long RunTimeTicks { get; set; }
-        public List<string> Genres { get; set; }
-        public List<string> Tags { get; set; }
-        public int ProductionYear { get; set; }
-        public JellyfinProviderIdsResponse ProviderIds { get; set; }
-        public string PremiereDate { get; set; }
-        public List<JellyfinMediaStreamResponse> MediaStreams { get; set; }
-        public string LocationType { get; set; }
-        public string Overview { get; set; }
-        public List<string> Taglines { get; set; }
-        public List<JellyfinStudioResponse> Studios { get; set; }
-        public List<JellyfinPersonResponse> People { get; set; }
-        public JellyfinImageTagsResponse ImageTags { get; set; }
-        public List<string> BackdropImageTags { get; set; }
-        public int? IndexNumber { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public string Id { get; set; }
+    public string Etag { get; set; }
+    public string Path { get; set; }
+    public string OfficialRating { get; set; }
+    public DateTimeOffset DateCreated { get; set; }
+    public long RunTimeTicks { get; set; }
+    public List<string> Genres { get; set; }
+    public List<string> Tags { get; set; }
+    public int ProductionYear { get; set; }
+    public JellyfinProviderIdsResponse ProviderIds { get; set; }
+    public string PremiereDate { get; set; }
+    public List<JellyfinMediaStreamResponse> MediaStreams { get; set; }
+    public string LocationType { get; set; }
+    public string Overview { get; set; }
+    public List<string> Taglines { get; set; }
+    public List<JellyfinStudioResponse> Studios { get; set; }
+    public List<JellyfinPersonResponse> People { get; set; }
+    public JellyfinImageTagsResponse ImageTags { get; set; }
+    public List<string> BackdropImageTags { get; set; }
+    public int? IndexNumber { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemsResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemsResponse.cs
index 2c4057d72..772fb53ec 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemsResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemsResponse.cs
@@ -1,9 +1,6 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
 
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+public class JellyfinLibraryItemsResponse
 {
-    public class JellyfinLibraryItemsResponse
-    {
-        public List<JellyfinLibraryItemResponse> Items { get; set; }
-    }
-}
+    public List<JellyfinLibraryItemResponse> Items { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryResponse.cs
index 857cd8179..6dcd9f85f 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryResponse.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinLibraryResponse
 {
-    public class JellyfinLibraryResponse
-    {
-        public string Name { get; set; }
-        public string CollectionType { get; set; }
-        public string ItemId { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public string CollectionType { get; set; }
+    public string ItemId { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinMediaStreamResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinMediaStreamResponse.cs
index 04fcbe657..7b24dd1f5 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinMediaStreamResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinMediaStreamResponse.cs
@@ -1,18 +1,17 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinMediaStreamResponse
 {
-    public class JellyfinMediaStreamResponse
-    {
-        public string Type { get; set; }
-        public string Codec { get; set; }
-        public string Language { get; set; }
-        public bool? IsInterlaced { get; set; }
-        public int? Height { get; set; }
-        public int? Width { get; set; }
-        public int Index { get; set; }
-        public bool IsDefault { get; set; }
-        public bool IsForced { get; set; }
-        public string Profile { get; set; }
-        public string AspectRatio { get; set; }
-        public int? Channels { get; set; }
-    }
-}
+    public string Type { get; set; }
+    public string Codec { get; set; }
+    public string Language { get; set; }
+    public bool? IsInterlaced { get; set; }
+    public int? Height { get; set; }
+    public int? Width { get; set; }
+    public int Index { get; set; }
+    public bool IsDefault { get; set; }
+    public bool IsForced { get; set; }
+    public string Profile { get; set; }
+    public string AspectRatio { get; set; }
+    public int? Channels { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinPersonResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinPersonResponse.cs
index 884cb429f..da885fdcf 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinPersonResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinPersonResponse.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinPersonResponse
 {
-    public class JellyfinPersonResponse
-    {
-        public string Name { get; set; }
-        public string Id { get; set; }
-        public string Role { get; set; }
-        public string Type { get; set; }
-        public string PrimaryImageTag { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public string Id { get; set; }
+    public string Role { get; set; }
+    public string Type { get; set; }
+    public string PrimaryImageTag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinProviderIdsResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinProviderIdsResponse.cs
index efaca5060..4a2fe82eb 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinProviderIdsResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinProviderIdsResponse.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinProviderIdsResponse
 {
-    public class JellyfinProviderIdsResponse
-    {
-        public string Imdb { get; set; }
-        public string Tmdb { get; set; }
-        public string Tvdb { get; set; }
-    }
-}
+    public string Imdb { get; set; }
+    public string Tmdb { get; set; }
+    public string Tvdb { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinStudioResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinStudioResponse.cs
index 2b055d2c7..73cd17aed 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinStudioResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinStudioResponse.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinStudioResponse
 {
-    public class JellyfinStudioResponse
-    {
-        public string Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public string Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinSystemInformationResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinSystemInformationResponse.cs
index d26dba5f1..af5d71769 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinSystemInformationResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinSystemInformationResponse.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinSystemInformationResponse
 {
-    public class JellyfinSystemInformationResponse
-    {
-        public string ServerName { get; set; }
-        public string OperatingSystem { get; set; }
-    }
-}
+    public string ServerName { get; set; }
+    public string OperatingSystem { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinUserPolicyResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinUserPolicyResponse.cs
index 14bb91f39..7f1bee371 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinUserPolicyResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinUserPolicyResponse.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinUserPolicyResponse
 {
-    public class JellyfinUserPolicyResponse
-    {
-        public bool IsAdministrator { get; set; }
-    }
-}
+    public bool IsAdministrator { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinUserResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinUserResponse.cs
index fe0539e65..0f02f139b 100644
--- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinUserResponse.cs
+++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinUserResponse.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Infrastructure.Jellyfin.Models
+namespace ErsatzTV.Infrastructure.Jellyfin.Models;
+
+public class JellyfinUserResponse
 {
-    public class JellyfinUserResponse
-    {
-        public string Name { get; set; }
-        public string Id { get; set; }
-        public JellyfinUserPolicyResponse Policy { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public string Id { get; set; }
+    public JellyfinUserPolicyResponse Policy { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Locking/EntityLocker.cs b/ErsatzTV.Infrastructure/Locking/EntityLocker.cs
index 656cf9873..da98ded56 100644
--- a/ErsatzTV.Infrastructure/Locking/EntityLocker.cs
+++ b/ErsatzTV.Infrastructure/Locking/EntityLocker.cs
@@ -1,132 +1,130 @@
-using System;
-using System.Collections.Concurrent;
+using System.Collections.Concurrent;
 using ErsatzTV.Core.Interfaces.Locking;
 
-namespace ErsatzTV.Infrastructure.Locking
+namespace ErsatzTV.Infrastructure.Locking;
+
+public class EntityLocker : IEntityLocker
 {
-    public class EntityLocker : IEntityLocker
+    private readonly ConcurrentDictionary<int, byte> _lockedLibraries;
+    private readonly ConcurrentDictionary<Type, byte> _lockedRemoteMediaSourceTypes;
+    private bool _plex;
+    private bool _trakt;
+
+    public EntityLocker()
     {
-        private readonly ConcurrentDictionary<int, byte> _lockedLibraries;
-        private readonly ConcurrentDictionary<Type, byte> _lockedRemoteMediaSourceTypes;
-        private bool _plex;
-        private bool _trakt;
-
-        public EntityLocker()
-        {
-            _lockedLibraries = new ConcurrentDictionary<int, byte>();
-            _lockedRemoteMediaSourceTypes = new ConcurrentDictionary<Type, byte>();
-        }
-
-        public event EventHandler OnLibraryChanged;
-        public event EventHandler OnPlexChanged;
-        public event EventHandler<Type> OnRemoteMediaSourceChanged;
-        public event EventHandler OnTraktChanged;
-
-        public bool LockLibrary(int libraryId)
-        {
-            if (!_lockedLibraries.ContainsKey(libraryId) && _lockedLibraries.TryAdd(libraryId, 0))
-            {
-                OnLibraryChanged?.Invoke(this, EventArgs.Empty);
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool UnlockLibrary(int libraryId)
-        {
-            if (_lockedLibraries.TryRemove(libraryId, out byte _))
-            {
-                OnLibraryChanged?.Invoke(this, EventArgs.Empty);
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool IsLibraryLocked(int libraryId) =>
-            _lockedLibraries.ContainsKey(libraryId);
-
-        public bool LockPlex()
-        {
-            if (!_plex)
-            {
-                _plex = true;
-                OnPlexChanged?.Invoke(this, EventArgs.Empty);
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool UnlockPlex()
-        {
-            if (_plex)
-            {
-                _plex = false;
-                OnPlexChanged?.Invoke(this, EventArgs.Empty);
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool IsPlexLocked() => _plex;
-
-        public bool IsRemoteMediaSourceLocked<TMediaSource>() =>
-            _lockedRemoteMediaSourceTypes.ContainsKey(typeof(TMediaSource));
-
-        public bool LockRemoteMediaSource<TMediaSource>()
-        {
-            Type mediaSourceType = typeof(TMediaSource);
-
-            if (!_lockedRemoteMediaSourceTypes.ContainsKey(mediaSourceType) &&
-                _lockedRemoteMediaSourceTypes.TryAdd(mediaSourceType, 0))
-            {
-                OnRemoteMediaSourceChanged?.Invoke(this, mediaSourceType);
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool UnlockRemoteMediaSource<TMediaSource>()
-        {
-            Type mediaSourceType = typeof(TMediaSource);
-
-            if (_lockedRemoteMediaSourceTypes.TryRemove(mediaSourceType, out byte _))
-            {
-                OnRemoteMediaSourceChanged?.Invoke(this, mediaSourceType);
-                return true;
-            }
-
-            return false;
-        }
-        
-        public bool LockTrakt()
-        {
-            if (!_trakt)
-            {
-                _trakt = true;
-                OnTraktChanged?.Invoke(this, EventArgs.Empty);
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool UnlockTrakt()
-        {
-            if (_trakt)
-            {
-                _trakt = false;
-                OnTraktChanged?.Invoke(this, EventArgs.Empty);
-                return true;
-            }
-
-            return false;
-        }
-
-        public bool IsTraktLocked() => _trakt;
+        _lockedLibraries = new ConcurrentDictionary<int, byte>();
+        _lockedRemoteMediaSourceTypes = new ConcurrentDictionary<Type, byte>();
     }
-}
+
+    public event EventHandler OnLibraryChanged;
+    public event EventHandler OnPlexChanged;
+    public event EventHandler<Type> OnRemoteMediaSourceChanged;
+    public event EventHandler OnTraktChanged;
+
+    public bool LockLibrary(int libraryId)
+    {
+        if (!_lockedLibraries.ContainsKey(libraryId) && _lockedLibraries.TryAdd(libraryId, 0))
+        {
+            OnLibraryChanged?.Invoke(this, EventArgs.Empty);
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool UnlockLibrary(int libraryId)
+    {
+        if (_lockedLibraries.TryRemove(libraryId, out byte _))
+        {
+            OnLibraryChanged?.Invoke(this, EventArgs.Empty);
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool IsLibraryLocked(int libraryId) =>
+        _lockedLibraries.ContainsKey(libraryId);
+
+    public bool LockPlex()
+    {
+        if (!_plex)
+        {
+            _plex = true;
+            OnPlexChanged?.Invoke(this, EventArgs.Empty);
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool UnlockPlex()
+    {
+        if (_plex)
+        {
+            _plex = false;
+            OnPlexChanged?.Invoke(this, EventArgs.Empty);
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool IsPlexLocked() => _plex;
+
+    public bool IsRemoteMediaSourceLocked<TMediaSource>() =>
+        _lockedRemoteMediaSourceTypes.ContainsKey(typeof(TMediaSource));
+
+    public bool LockRemoteMediaSource<TMediaSource>()
+    {
+        Type mediaSourceType = typeof(TMediaSource);
+
+        if (!_lockedRemoteMediaSourceTypes.ContainsKey(mediaSourceType) &&
+            _lockedRemoteMediaSourceTypes.TryAdd(mediaSourceType, 0))
+        {
+            OnRemoteMediaSourceChanged?.Invoke(this, mediaSourceType);
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool UnlockRemoteMediaSource<TMediaSource>()
+    {
+        Type mediaSourceType = typeof(TMediaSource);
+
+        if (_lockedRemoteMediaSourceTypes.TryRemove(mediaSourceType, out byte _))
+        {
+            OnRemoteMediaSourceChanged?.Invoke(this, mediaSourceType);
+            return true;
+        }
+
+        return false;
+    }
+        
+    public bool LockTrakt()
+    {
+        if (!_trakt)
+        {
+            _trakt = true;
+            OnTraktChanged?.Invoke(this, EventArgs.Empty);
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool UnlockTrakt()
+    {
+        if (_trakt)
+        {
+            _trakt = false;
+            OnTraktChanged?.Invoke(this, EventArgs.Empty);
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool IsTraktLocked() => _trakt;
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/IPlexServerApi.cs b/ErsatzTV.Infrastructure/Plex/IPlexServerApi.cs
index f79869a16..e429e8e91 100644
--- a/ErsatzTV.Infrastructure/Plex/IPlexServerApi.cs
+++ b/ErsatzTV.Infrastructure/Plex/IPlexServerApi.cs
@@ -1,61 +1,59 @@
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Plex.Models;
+using ErsatzTV.Infrastructure.Plex.Models;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.Plex
+namespace ErsatzTV.Infrastructure.Plex;
+
+public interface IPlexServerApi
 {
-    public interface IPlexServerApi
-    {
-        [Get("/")]
-        [Headers("Accept: application/json")]
-        public Task Ping(
+    [Get("/")]
+    [Headers("Accept: application/json")]
+    public Task Ping(
+        [Query] [AliasAs("X-Plex-Token")]
+        string token);
+
+    [Get("/library/sections")]
+    [Headers("Accept: application/json")]
+    public Task<PlexMediaContainerResponse<PlexMediaContainerDirectoryContent<PlexLibraryResponse>>> GetLibraries(
+        [Query] [AliasAs("X-Plex-Token")]
+        string token);
+
+    [Get("/library/sections/{key}/all")]
+    [Headers("Accept: application/json")]
+    public Task<PlexMediaContainerResponse<PlexMediaContainerMetadataContent<PlexMetadataResponse>>>
+        GetLibrarySectionContents(
+            string key,
             [Query] [AliasAs("X-Plex-Token")]
             string token);
 
-        [Get("/library/sections")]
-        [Headers("Accept: application/json")]
-        public Task<PlexMediaContainerResponse<PlexMediaContainerDirectoryContent<PlexLibraryResponse>>> GetLibraries(
+    [Get("/library/metadata/{key}")]
+    [Headers("Accept: text/xml")]
+    public Task<PlexXmlVideoMetadataResponseContainer>
+        GetVideoMetadata(
+            string key,
             [Query] [AliasAs("X-Plex-Token")]
             string token);
 
-        [Get("/library/sections/{key}/all")]
-        [Headers("Accept: application/json")]
-        public Task<PlexMediaContainerResponse<PlexMediaContainerMetadataContent<PlexMetadataResponse>>>
-            GetLibrarySectionContents(
-                string key,
-                [Query] [AliasAs("X-Plex-Token")]
-                string token);
+    [Get("/library/metadata/{key}")]
+    [Headers("Accept: text/xml")]
+    public Task<PlexXmlDirectoryMetadataResponseContainer>
+        GetDirectoryMetadata(
+            string key,
+            [Query] [AliasAs("X-Plex-Token")]
+            string token);
 
-        [Get("/library/metadata/{key}")]
-        [Headers("Accept: text/xml")]
-        public Task<PlexXmlVideoMetadataResponseContainer>
-            GetVideoMetadata(
-                string key,
-                [Query] [AliasAs("X-Plex-Token")]
-                string token);
+    [Get("/library/metadata/{key}/children")]
+    [Headers("Accept: text/xml")]
+    public Task<PlexXmlSeasonsMetadataResponseContainer>
+        GetShowChildren(
+            string key,
+            [Query] [AliasAs("X-Plex-Token")]
+            string token);
 
-        [Get("/library/metadata/{key}")]
-        [Headers("Accept: text/xml")]
-        public Task<PlexXmlDirectoryMetadataResponseContainer>
-            GetDirectoryMetadata(
-                string key,
-                [Query] [AliasAs("X-Plex-Token")]
-                string token);
-
-        [Get("/library/metadata/{key}/children")]
-        [Headers("Accept: text/xml")]
-        public Task<PlexXmlSeasonsMetadataResponseContainer>
-            GetShowChildren(
-                string key,
-                [Query] [AliasAs("X-Plex-Token")]
-                string token);
-
-        [Get("/library/metadata/{key}/children")]
-        [Headers("Accept: text/xml")]
-        public Task<PlexXmlEpisodesMetadataResponseContainer>
-            GetSeasonChildren(
-                string key,
-                [Query] [AliasAs("X-Plex-Token")]
-                string token);
-    }
-}
+    [Get("/library/metadata/{key}/children")]
+    [Headers("Accept: text/xml")]
+    public Task<PlexXmlEpisodesMetadataResponseContainer>
+        GetSeasonChildren(
+            string key,
+            [Query] [AliasAs("X-Plex-Token")]
+            string token);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/IPlexTvApi.cs b/ErsatzTV.Infrastructure/Plex/IPlexTvApi.cs
index 84503e450..08ebb23d6 100644
--- a/ErsatzTV.Infrastructure/Plex/IPlexTvApi.cs
+++ b/ErsatzTV.Infrastructure/Plex/IPlexTvApi.cs
@@ -1,46 +1,43 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Plex.Models;
+using ErsatzTV.Infrastructure.Plex.Models;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.Plex
+namespace ErsatzTV.Infrastructure.Plex;
+
+[Headers("Accept: application/json")]
+public interface IPlexTvApi
 {
-    [Headers("Accept: application/json")]
-    public interface IPlexTvApi
-    {
-        [Post("/pins")]
-        Task<PlexPinResponse> StartPinFlow(
-            [Query] [AliasAs("X-Plex-Product")]
-            string product,
-            [Query] [AliasAs("X-Plex-Client-Identifier")]
-            string clientIdentifier,
-            [Query]
-            bool strong = true);
+    [Post("/pins")]
+    Task<PlexPinResponse> StartPinFlow(
+        [Query] [AliasAs("X-Plex-Product")]
+        string product,
+        [Query] [AliasAs("X-Plex-Client-Identifier")]
+        string clientIdentifier,
+        [Query]
+        bool strong = true);
 
-        [Get("/pins/{id}")]
-        Task<PlexTokenResponse> GetPinStatus(
-            int id,
-            [Query]
-            string code,
-            [Query] [AliasAs("X-Plex-Client-Identifier")]
-            string clientIdentifier);
+    [Get("/pins/{id}")]
+    Task<PlexTokenResponse> GetPinStatus(
+        int id,
+        [Query]
+        string code,
+        [Query] [AliasAs("X-Plex-Client-Identifier")]
+        string clientIdentifier);
 
-        [Get("/user")]
-        Task<PlexUserResponse> GetUser(
-            [Query] [AliasAs("X-Plex-Product")]
-            string product,
-            [Query] [AliasAs("X-Plex-Client-Identifier")]
-            string clientIdentifier,
-            [Query] [AliasAs("X-Plex-Token")]
-            string token);
+    [Get("/user")]
+    Task<PlexUserResponse> GetUser(
+        [Query] [AliasAs("X-Plex-Product")]
+        string product,
+        [Query] [AliasAs("X-Plex-Client-Identifier")]
+        string clientIdentifier,
+        [Query] [AliasAs("X-Plex-Token")]
+        string token);
 
-        [Get("/resources")]
-        Task<List<PlexResource>> GetResources(
-            [Query] [AliasAs("includeHttps")]
-            int includeHttps,
-            [Header("X-Plex-Client-Identifier")]
-            string clientIdentifier,
-            [Header("X-Plex-Token")]
-            string token);
-    }
-}
+    [Get("/resources")]
+    Task<List<PlexResource>> GetResources(
+        [Query] [AliasAs("includeHttps")]
+        int includeHttps,
+        [Header("X-Plex-Client-Identifier")]
+        string clientIdentifier,
+        [Header("X-Plex-Token")]
+        string token);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexDirectorResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexDirectorResponse.cs
index 7f8179293..803636604 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexDirectorResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexDirectorResponse.cs
@@ -1,10 +1,9 @@
 using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexDirectorResponse
 {
-    public class PlexDirectorResponse
-    {
-        [XmlAttribute("tag")]
-        public string Tag { get; set; }
-    }
-}
+    [XmlAttribute("tag")]
+    public string Tag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexGenreResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexGenreResponse.cs
index e963d7878..741d2c190 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexGenreResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexGenreResponse.cs
@@ -1,16 +1,15 @@
 using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexGenreResponse
 {
-    public class PlexGenreResponse
-    {
-        [XmlAttribute("id")]
-        public int Id { get; set; }
+    [XmlAttribute("id")]
+    public int Id { get; set; }
 
-        [XmlAttribute("filter")]
-        public string Filter { get; set; }
+    [XmlAttribute("filter")]
+    public string Filter { get; set; }
 
-        [XmlAttribute("tag")]
-        public string Tag { get; set; }
-    }
-}
+    [XmlAttribute("tag")]
+    public string Tag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexGuidResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexGuidResponse.cs
index 61ca35d72..34b6d88c0 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexGuidResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexGuidResponse.cs
@@ -1,10 +1,9 @@
 using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexGuidResponse
 {
-    public class PlexGuidResponse
-    {
-        [XmlAttribute("id")]
-        public string Id { get; set; }
-    }
-}
+    [XmlAttribute("id")]
+    public string Id { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexLibraryResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexLibraryResponse.cs
index 45602b36f..cf7e07168 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexLibraryResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexLibraryResponse.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexLibraryResponse
 {
-    public class PlexLibraryResponse
-    {
-        public string Key { get; set; }
-        public string Title { get; set; }
-        public string Type { get; set; }
-        public int Hidden { get; set; }
-        public string Uuid { get; set; }
-    }
-}
+    public string Key { get; set; }
+    public string Title { get; set; }
+    public string Type { get; set; }
+    public int Hidden { get; set; }
+    public string Uuid { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexMediaContainerResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexMediaContainerResponse.cs
index 766ffe8c7..d44543cfc 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexMediaContainerResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexMediaContainerResponse.cs
@@ -1,48 +1,46 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexMediaContainerResponse<T>
 {
-    public class PlexMediaContainerResponse<T>
-    {
-        public T MediaContainer { get; set; }
-    }
-
-    public class PlexMediaContainerDirectoryContent<T>
-    {
-        public List<T> Directory { get; set; }
-    }
-
-    public class PlexMediaContainerMetadataContent<T>
-    {
-        public List<T> Metadata { get; set; }
-    }
-
-    [XmlRoot("MediaContainer", Namespace = null)]
-    public class PlexXmlVideoMetadataResponseContainer
-    {
-        [XmlElement("Video")]
-        public PlexXmlMetadataResponse Metadata { get; set; }
-    }
-
-    [XmlRoot("MediaContainer", Namespace = null)]
-    public class PlexXmlDirectoryMetadataResponseContainer
-    {
-        [XmlElement("Directory")]
-        public PlexXmlMetadataResponse Metadata { get; set; }
-    }
-
-    [XmlRoot("MediaContainer", Namespace = null)]
-    public class PlexXmlSeasonsMetadataResponseContainer
-    {
-        [XmlElement("Directory")]
-        public List<PlexXmlMetadataResponse> Metadata { get; set; }
-    }
-
-    [XmlRoot("MediaContainer", Namespace = null)]
-    public class PlexXmlEpisodesMetadataResponseContainer
-    {
-        [XmlElement("Video")]
-        public List<PlexXmlMetadataResponse> Metadata { get; set; }
-    }
+    public T MediaContainer { get; set; }
 }
+
+public class PlexMediaContainerDirectoryContent<T>
+{
+    public List<T> Directory { get; set; }
+}
+
+public class PlexMediaContainerMetadataContent<T>
+{
+    public List<T> Metadata { get; set; }
+}
+
+[XmlRoot("MediaContainer", Namespace = null)]
+public class PlexXmlVideoMetadataResponseContainer
+{
+    [XmlElement("Video")]
+    public PlexXmlMetadataResponse Metadata { get; set; }
+}
+
+[XmlRoot("MediaContainer", Namespace = null)]
+public class PlexXmlDirectoryMetadataResponseContainer
+{
+    [XmlElement("Directory")]
+    public PlexXmlMetadataResponse Metadata { get; set; }
+}
+
+[XmlRoot("MediaContainer", Namespace = null)]
+public class PlexXmlSeasonsMetadataResponseContainer
+{
+    [XmlElement("Directory")]
+    public List<PlexXmlMetadataResponse> Metadata { get; set; }
+}
+
+[XmlRoot("MediaContainer", Namespace = null)]
+public class PlexXmlEpisodesMetadataResponseContainer
+{
+    [XmlElement("Video")]
+    public List<PlexXmlMetadataResponse> Metadata { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexMediaResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexMediaResponse.cs
index 7cf54e4cb..2433b3817 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexMediaResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexMediaResponse.cs
@@ -1,50 +1,48 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexMediaResponse<T>
 {
-    public class PlexMediaResponse<T>
-    {
-        [XmlAttribute("id")]
-        public int Id { get; set; }
+    [XmlAttribute("id")]
+    public int Id { get; set; }
 
-        [XmlAttribute("duration")]
-        public int Duration { get; set; }
+    [XmlAttribute("duration")]
+    public int Duration { get; set; }
 
-        [XmlAttribute("bitrate")]
-        public int Bitrate { get; set; }
+    [XmlAttribute("bitrate")]
+    public int Bitrate { get; set; }
 
-        [XmlAttribute("width")]
-        public int Width { get; set; }
+    [XmlAttribute("width")]
+    public int Width { get; set; }
 
-        [XmlAttribute("height")]
-        public int Height { get; set; }
+    [XmlAttribute("height")]
+    public int Height { get; set; }
 
-        [XmlAttribute("aspectRatio")]
-        public double AspectRatio { get; set; }
+    [XmlAttribute("aspectRatio")]
+    public double AspectRatio { get; set; }
 
-        [XmlAttribute("audioChannels")]
-        public int AudioChannels { get; set; }
+    [XmlAttribute("audioChannels")]
+    public int AudioChannels { get; set; }
 
-        [XmlAttribute("audioCodec")]
-        public string AudioCodec { get; set; }
+    [XmlAttribute("audioCodec")]
+    public string AudioCodec { get; set; }
 
-        [XmlAttribute("videoCodec")]
-        public string VideoCodec { get; set; }
+    [XmlAttribute("videoCodec")]
+    public string VideoCodec { get; set; }
 
-        [XmlAttribute("videoResulution")]
-        public string VideoResolution { get; set; }
+    [XmlAttribute("videoResulution")]
+    public string VideoResolution { get; set; }
 
-        [XmlAttribute("videoProfile")]
-        public string VideoProfile { get; set; }
+    [XmlAttribute("videoProfile")]
+    public string VideoProfile { get; set; }
 
-        [XmlAttribute("container")]
-        public string Container { get; set; }
+    [XmlAttribute("container")]
+    public string Container { get; set; }
 
-        [XmlAttribute("videoFrameRate")]
-        public string VideoFrameRate { get; set; }
+    [XmlAttribute("videoFrameRate")]
+    public string VideoFrameRate { get; set; }
 
-        [XmlElement("Part")]
-        public List<T> Part { get; set; }
-    }
-}
+    [XmlElement("Part")]
+    public List<T> Part { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexMetadataResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexMetadataResponse.cs
index a4386b75d..32b963321 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexMetadataResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexMetadataResponse.cs
@@ -1,74 +1,72 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexMetadataResponse
 {
-    public class PlexMetadataResponse
-    {
-        [XmlAttribute("key")]
-        public string Key { get; set; }
+    [XmlAttribute("key")]
+    public string Key { get; set; }
 
-        [XmlAttribute("title")]
-        public string Title { get; set; }
+    [XmlAttribute("title")]
+    public string Title { get; set; }
 
-        [XmlAttribute("contentRating")]
-        public string ContentRating { get; set; }
+    [XmlAttribute("contentRating")]
+    public string ContentRating { get; set; }
 
-        [XmlAttribute("summary")]
-        public string Summary { get; set; }
+    [XmlAttribute("summary")]
+    public string Summary { get; set; }
 
-        [XmlAttribute("year")]
-        public int Year { get; set; }
+    [XmlAttribute("year")]
+    public int Year { get; set; }
 
-        [XmlAttribute("tagline")]
-        public string Tagline { get; set; }
+    [XmlAttribute("tagline")]
+    public string Tagline { get; set; }
 
-        [XmlAttribute("thumb")]
-        public string Thumb { get; set; }
+    [XmlAttribute("thumb")]
+    public string Thumb { get; set; }
 
-        [XmlAttribute("art")]
-        public string Art { get; set; }
+    [XmlAttribute("art")]
+    public string Art { get; set; }
 
-        [XmlAttribute("originallyAvailableAt")]
-        public string OriginallyAvailableAt { get; set; }
+    [XmlAttribute("originallyAvailableAt")]
+    public string OriginallyAvailableAt { get; set; }
 
-        [XmlAttribute("addedAt")]
-        public long AddedAt { get; set; }
+    [XmlAttribute("addedAt")]
+    public long AddedAt { get; set; }
 
-        [XmlAttribute("updatedAt")]
-        public long UpdatedAt { get; set; }
+    [XmlAttribute("updatedAt")]
+    public long UpdatedAt { get; set; }
 
-        [XmlAttribute("index")]
-        public int Index { get; set; }
+    [XmlAttribute("index")]
+    public int Index { get; set; }
 
-        [XmlAttribute("studio")]
-        public string Studio { get; set; }
+    [XmlAttribute("studio")]
+    public string Studio { get; set; }
 
-        [XmlAttribute("rating")]
-        public double Rating { get; set; }
+    [XmlAttribute("rating")]
+    public double Rating { get; set; }
 
-        [XmlAttribute("audienceRating")]
-        public double AudienceRating { get; set; }
+    [XmlAttribute("audienceRating")]
+    public double AudienceRating { get; set; }
 
-        [XmlAttribute("audienceRatingImage")]
-        public string AudienceRatingImage { get; set; }
+    [XmlAttribute("audienceRatingImage")]
+    public string AudienceRatingImage { get; set; }
 
-        [XmlAttribute("ratingImage")]
-        public string RatingImage { get; set; }
+    [XmlAttribute("ratingImage")]
+    public string RatingImage { get; set; }
 
-        [XmlIgnore]
-        public virtual List<PlexMediaResponse<PlexPartResponse>> Media { get; set; }
+    [XmlIgnore]
+    public virtual List<PlexMediaResponse<PlexPartResponse>> Media { get; set; }
 
-        [XmlElement("Genre")]
-        public List<PlexGenreResponse> Genre { get; set; }
+    [XmlElement("Genre")]
+    public List<PlexGenreResponse> Genre { get; set; }
 
-        [XmlElement("Role")]
-        public List<PlexRoleResponse> Role { get; set; }
+    [XmlElement("Role")]
+    public List<PlexRoleResponse> Role { get; set; }
 
-        [XmlElement("Director")]
-        public List<PlexDirectorResponse> Director { get; set; }
+    [XmlElement("Director")]
+    public List<PlexDirectorResponse> Director { get; set; }
 
-        [XmlElement("Writer")]
-        public List<PlexWriterResponse> Writer { get; set; }
-    }
-}
+    [XmlElement("Writer")]
+    public List<PlexWriterResponse> Writer { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexPartResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexPartResponse.cs
index c8a09a21d..938696bea 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexPartResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexPartResponse.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexPartResponse
 {
-    public class PlexPartResponse
-    {
-        public int Id { get; set; }
-        public string Key { get; set; }
-        public int Duration { get; set; }
-        public string File { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Key { get; set; }
+    public int Duration { get; set; }
+    public string File { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexPinResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexPinResponse.cs
index 3f70cd55c..f69a97e46 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexPinResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexPinResponse.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexPinResponse
 {
-    public class PlexPinResponse
-    {
-        public int Id { get; set; }
-        public string Code { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Code { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexResource.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexResource.cs
index cb0e8c668..b1ca0a284 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexResource.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexResource.cs
@@ -1,20 +1,17 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Infrastructure.Plex.Models;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+public class PlexResource
 {
-    public class PlexResource
-    {
-        public string Name { get; set; }
-        public string ProductVersion { get; set; }
-        public string Platform { get; set; }
-        public string PlatformVersion { get; set; }
-        public string ClientIdentifier { get; set; }
+    public string Name { get; set; }
+    public string ProductVersion { get; set; }
+    public string Platform { get; set; }
+    public string PlatformVersion { get; set; }
+    public string ClientIdentifier { get; set; }
 
-        public string AccessToken { get; set; }
+    public string AccessToken { get; set; }
 
-        public bool Owned { get; set; }
-        public string Provides { get; set; }
-        public bool HttpsRequired { get; set; }
-        public List<PlexResourceConnection> Connections { get; set; }
-    }
-}
+    public bool Owned { get; set; }
+    public string Provides { get; set; }
+    public bool HttpsRequired { get; set; }
+    public List<PlexResourceConnection> Connections { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexResourceConnection.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexResourceConnection.cs
index 6f1a8e1c4..470568487 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexResourceConnection.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexResourceConnection.cs
@@ -1,11 +1,10 @@
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexResourceConnection
 {
-    public class PlexResourceConnection
-    {
-        public string Protocol { get; set; }
-        public string Address { get; set; }
-        public int Port { get; set; }
-        public string Uri { get; set; }
-        public bool Local { get; set; }
-    }
-}
+    public string Protocol { get; set; }
+    public string Address { get; set; }
+    public int Port { get; set; }
+    public string Uri { get; set; }
+    public bool Local { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexRoleResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexRoleResponse.cs
index c5a7c31d0..6a7be096e 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexRoleResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexRoleResponse.cs
@@ -1,16 +1,15 @@
 using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexRoleResponse
 {
-    public class PlexRoleResponse
-    {
-        [XmlAttribute("tag")]
-        public string Tag { get; set; }
+    [XmlAttribute("tag")]
+    public string Tag { get; set; }
 
-        [XmlAttribute("role")]
-        public string Role { get; set; }
+    [XmlAttribute("role")]
+    public string Role { get; set; }
 
-        [XmlAttribute("thumb")]
-        public string Thumb { get; set; }
-    }
-}
+    [XmlAttribute("thumb")]
+    public string Thumb { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexStreamResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexStreamResponse.cs
index c9e02cf84..2bfd1d2aa 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexStreamResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexStreamResponse.cs
@@ -1,43 +1,42 @@
 using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexStreamResponse
 {
-    public class PlexStreamResponse
-    {
-        [XmlAttribute("id")]
-        public int Id { get; set; }
+    [XmlAttribute("id")]
+    public int Id { get; set; }
 
-        [XmlAttribute("index")]
-        public int Index { get; set; }
+    [XmlAttribute("index")]
+    public int Index { get; set; }
 
-        [XmlAttribute("default")]
-        public bool Default { get; set; }
+    [XmlAttribute("default")]
+    public bool Default { get; set; }
 
-        [XmlAttribute("forced")]
-        public bool Forced { get; set; }
+    [XmlAttribute("forced")]
+    public bool Forced { get; set; }
 
-        [XmlAttribute("languageCode")]
-        public string LanguageCode { get; set; }
+    [XmlAttribute("languageCode")]
+    public string LanguageCode { get; set; }
 
-        [XmlAttribute("streamType")]
-        public int StreamType { get; set; }
+    [XmlAttribute("streamType")]
+    public int StreamType { get; set; }
 
-        [XmlAttribute("codec")]
-        public string Codec { get; set; }
+    [XmlAttribute("codec")]
+    public string Codec { get; set; }
 
-        [XmlAttribute("profile")]
-        public string Profile { get; set; }
+    [XmlAttribute("profile")]
+    public string Profile { get; set; }
 
-        [XmlAttribute("channels")]
-        public int Channels { get; set; }
+    [XmlAttribute("channels")]
+    public int Channels { get; set; }
 
-        [XmlAttribute("anamorphic")]
-        public bool Anamorphic { get; set; }
+    [XmlAttribute("anamorphic")]
+    public bool Anamorphic { get; set; }
 
-        [XmlAttribute("pixelAspectRatio")]
-        public string PixelAspectRatio { get; set; }
+    [XmlAttribute("pixelAspectRatio")]
+    public string PixelAspectRatio { get; set; }
 
-        [XmlAttribute("scanType")]
-        public string ScanType { get; set; }
-    }
-}
+    [XmlAttribute("scanType")]
+    public string ScanType { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexTokenResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexTokenResponse.cs
index 91d87bd61..45b4a5096 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexTokenResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexTokenResponse.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexTokenResponse
 {
-    public class PlexTokenResponse
-    {
-        public string AuthToken { get; set; }
-    }
-}
+    public string AuthToken { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexUserResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexUserResponse.cs
index b580ac054..571a61d9d 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexUserResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexUserResponse.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexUserResponse
 {
-    public class PlexUserResponse
-    {
-        public string Email { get; set; }
-        public string AuthToken { get; set; }
-    }
-}
+    public string Email { get; set; }
+    public string AuthToken { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexWriterResponse.mcs.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexWriterResponse.mcs.cs
index 352c5fad7..f07582fa4 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexWriterResponse.mcs.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexWriterResponse.mcs.cs
@@ -1,10 +1,9 @@
 using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexWriterResponse
 {
-    public class PlexWriterResponse
-    {
-        [XmlAttribute("tag")]
-        public string Tag { get; set; }
-    }
-}
+    [XmlAttribute("tag")]
+    public string Tag { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexXmlMetadataResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexXmlMetadataResponse.cs
index c91e62fb1..ec501301a 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexXmlMetadataResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexXmlMetadataResponse.cs
@@ -1,17 +1,15 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexXmlMetadataResponse : PlexMetadataResponse
 {
-    public class PlexXmlMetadataResponse : PlexMetadataResponse
-    {
-        [XmlAttribute("guid")]
-        public string PlexGuid { get; set; }
+    [XmlAttribute("guid")]
+    public string PlexGuid { get; set; }
 
-        [XmlElement("Media")]
-        public new List<PlexMediaResponse<PlexXmlPartResponse>> Media { get; set; }
+    [XmlElement("Media")]
+    public new List<PlexMediaResponse<PlexXmlPartResponse>> Media { get; set; }
 
-        [XmlElement("Guid")]
-        public List<PlexGuidResponse> Guid { get; set; }
-    }
-}
+    [XmlElement("Guid")]
+    public List<PlexGuidResponse> Guid { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/Models/PlexXmlPartResponse.cs b/ErsatzTV.Infrastructure/Plex/Models/PlexXmlPartResponse.cs
index 6d4d33f2e..218a3a851 100644
--- a/ErsatzTV.Infrastructure/Plex/Models/PlexXmlPartResponse.cs
+++ b/ErsatzTV.Infrastructure/Plex/Models/PlexXmlPartResponse.cs
@@ -1,23 +1,21 @@
-using System.Collections.Generic;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 
-namespace ErsatzTV.Infrastructure.Plex.Models
+namespace ErsatzTV.Infrastructure.Plex.Models;
+
+public class PlexXmlPartResponse
 {
-    public class PlexXmlPartResponse
-    {
-        [XmlAttribute("id")]
-        public int Id { get; set; }
+    [XmlAttribute("id")]
+    public int Id { get; set; }
 
-        [XmlAttribute("key")]
-        public string Key { get; set; }
+    [XmlAttribute("key")]
+    public string Key { get; set; }
 
-        [XmlAttribute("duration")]
-        public int Duration { get; set; }
+    [XmlAttribute("duration")]
+    public int Duration { get; set; }
 
-        [XmlAttribute("file")]
-        public string File { get; set; }
+    [XmlAttribute("file")]
+    public string File { get; set; }
 
-        [XmlElement("Stream")]
-        public List<PlexStreamResponse> Stream { get; set; }
-    }
-}
+    [XmlElement("Stream")]
+    public List<PlexStreamResponse> Stream { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/PlexSecretStore.cs b/ErsatzTV.Infrastructure/Plex/PlexSecretStore.cs
index 6f1a156cc..97fa2e5b3 100644
--- a/ErsatzTV.Infrastructure/Plex/PlexSecretStore.cs
+++ b/ErsatzTV.Infrastructure/Plex/PlexSecretStore.cs
@@ -1,84 +1,76 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Plex;
-using LanguageExt;
 using Newtonsoft.Json;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Plex
+namespace ErsatzTV.Infrastructure.Plex;
+
+public class PlexSecretStore : IPlexSecretStore
 {
-    public class PlexSecretStore : IPlexSecretStore
-    {
-        public Task<string> GetClientIdentifier() =>
-            ReadSecrets().Bind(
-                plexSecrets => Optional(plexSecrets.ClientIdentifier).Match(
-                    Task.FromResult,
-                    async () =>
-                    {
-                        string identifier = GenerateClientIdentifier();
-                        plexSecrets.ClientIdentifier = identifier;
-                        await SaveSecrets(plexSecrets);
-                        return identifier;
-                    }));
-
-        public Task<List<PlexUserAuthToken>> GetUserAuthTokens() =>
-            ReadSecrets().Map(
-                s => Optional(s.UserAuthTokens).Match(
-                    tokens => tokens.Map(kvp => new PlexUserAuthToken(kvp.Key, kvp.Value)).ToList(),
-                    () => new List<PlexUserAuthToken>()));
-
-        public Task<Option<PlexServerAuthToken>> GetServerAuthToken(string clientIdentifier) =>
-            ReadSecrets().Map(
-                s => Optional(s.ServerAuthTokens.SingleOrDefault(kvp => kvp.Key == clientIdentifier))
-                    .Map(kvp => new PlexServerAuthToken(kvp.Key, kvp.Value)));
-
-        public Task<Unit> UpsertUserAuthToken(PlexUserAuthToken userAuthToken) =>
-            ReadSecrets().Bind(
-                secrets =>
+    public Task<string> GetClientIdentifier() =>
+        ReadSecrets().Bind(
+            plexSecrets => Optional(plexSecrets.ClientIdentifier).Match(
+                Task.FromResult,
+                async () =>
                 {
-                    secrets.UserAuthTokens ??= new Dictionary<string, string>();
-                    secrets.UserAuthTokens[userAuthToken.Email] = userAuthToken.AuthToken;
-                    return SaveSecrets(secrets);
+                    string identifier = GenerateClientIdentifier();
+                    plexSecrets.ClientIdentifier = identifier;
+                    await SaveSecrets(plexSecrets);
+                    return identifier;
+                }));
+
+    public Task<List<PlexUserAuthToken>> GetUserAuthTokens() =>
+        ReadSecrets().Map(
+            s => Optional(s.UserAuthTokens).Match(
+                tokens => tokens.Map(kvp => new PlexUserAuthToken(kvp.Key, kvp.Value)).ToList(),
+                () => new List<PlexUserAuthToken>()));
+
+    public Task<Option<PlexServerAuthToken>> GetServerAuthToken(string clientIdentifier) =>
+        ReadSecrets().Map(
+            s => Optional(s.ServerAuthTokens.SingleOrDefault(kvp => kvp.Key == clientIdentifier))
+                .Map(kvp => new PlexServerAuthToken(kvp.Key, kvp.Value)));
+
+    public Task<Unit> UpsertUserAuthToken(PlexUserAuthToken userAuthToken) =>
+        ReadSecrets().Bind(
+            secrets =>
+            {
+                secrets.UserAuthTokens ??= new Dictionary<string, string>();
+                secrets.UserAuthTokens[userAuthToken.Email] = userAuthToken.AuthToken;
+                return SaveSecrets(secrets);
+            });
+
+    public Task<Unit> UpsertServerAuthToken(PlexServerAuthToken serverAuthToken) =>
+        ReadSecrets().Bind(
+            secrets =>
+            {
+                secrets.ServerAuthTokens ??= new Dictionary<string, string>();
+                secrets.ServerAuthTokens[serverAuthToken.ClientIdentifier] = serverAuthToken.AuthToken;
+                return SaveSecrets(secrets);
+            });
+
+    public Task<Unit> DeleteAll() =>
+        ReadSecrets().Bind(secrets => SaveSecrets(new PlexSecrets { ClientIdentifier = secrets.ClientIdentifier }));
+
+    private static Task<PlexSecrets> ReadSecrets() =>
+        File.ReadAllTextAsync(FileSystemLayout.PlexSecretsPath)
+            .Map(JsonConvert.DeserializeObject<PlexSecrets>)
+            .Map(s => Optional(s).IfNone(new PlexSecrets()))
+            .Map(
+                s =>
+                {
+                    s.ServerAuthTokens ??= new Dictionary<string, string>();
+                    s.UserAuthTokens ??= new Dictionary<string, string>();
+                    return s;
                 });
 
-        public Task<Unit> UpsertServerAuthToken(PlexServerAuthToken serverAuthToken) =>
-            ReadSecrets().Bind(
-                secrets =>
-                {
-                    secrets.ServerAuthTokens ??= new Dictionary<string, string>();
-                    secrets.ServerAuthTokens[serverAuthToken.ClientIdentifier] = serverAuthToken.AuthToken;
-                    return SaveSecrets(secrets);
-                });
+    private static Task<Unit> SaveSecrets(PlexSecrets plexSecrets) =>
+        Some(JsonConvert.SerializeObject(plexSecrets)).Match(
+            s => File.WriteAllTextAsync(FileSystemLayout.PlexSecretsPath, s).ToUnit(),
+            Task.FromResult(Unit.Default));
 
-        public Task<Unit> DeleteAll() =>
-            ReadSecrets().Bind(secrets => SaveSecrets(new PlexSecrets { ClientIdentifier = secrets.ClientIdentifier }));
-
-        private static Task<PlexSecrets> ReadSecrets() =>
-            File.ReadAllTextAsync(FileSystemLayout.PlexSecretsPath)
-                .Map(JsonConvert.DeserializeObject<PlexSecrets>)
-                .Map(s => Optional(s).IfNone(new PlexSecrets()))
-                .Map(
-                    s =>
-                    {
-                        s.ServerAuthTokens ??= new Dictionary<string, string>();
-                        s.UserAuthTokens ??= new Dictionary<string, string>();
-                        return s;
-                    });
-
-        private static Task<Unit> SaveSecrets(PlexSecrets plexSecrets) =>
-            Some(JsonConvert.SerializeObject(plexSecrets)).Match(
-                s => File.WriteAllTextAsync(FileSystemLayout.PlexSecretsPath, s).ToUnit(),
-                Task.FromResult(Unit.Default));
-
-        private static string GenerateClientIdentifier() =>
-            Convert.ToBase64String(Guid.NewGuid().ToByteArray())
-                .TrimEnd('=')
-                .Replace("/", "_")
-                .Replace("+", "-");
-    }
-}
+    private static string GenerateClientIdentifier() =>
+        Convert.ToBase64String(Guid.NewGuid().ToByteArray())
+            .TrimEnd('=')
+            .Replace("/", "_")
+            .Replace("+", "-");
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/PlexSecrets.cs b/ErsatzTV.Infrastructure/Plex/PlexSecrets.cs
index 124f08613..a53a65ad2 100644
--- a/ErsatzTV.Infrastructure/Plex/PlexSecrets.cs
+++ b/ErsatzTV.Infrastructure/Plex/PlexSecrets.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
+namespace ErsatzTV.Infrastructure.Plex;
 
-namespace ErsatzTV.Infrastructure.Plex
+public class PlexSecrets
 {
-    public class PlexSecrets
-    {
-        public string ClientIdentifier { get; set; }
-        public Dictionary<string, string> UserAuthTokens { get; set; }
-        public Dictionary<string, string> ServerAuthTokens { get; set; }
-    }
-}
+    public string ClientIdentifier { get; set; }
+    public Dictionary<string, string> UserAuthTokens { get; set; }
+    public Dictionary<string, string> ServerAuthTokens { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/PlexServerApiClient.cs b/ErsatzTV.Infrastructure/Plex/PlexServerApiClient.cs
index 262bcd4b0..9a1626e28 100644
--- a/ErsatzTV.Infrastructure/Plex/PlexServerApiClient.cs
+++ b/ErsatzTV.Infrastructure/Plex/PlexServerApiClient.cs
@@ -1,647 +1,393 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net.Http;
-using System.Threading.Tasks;
-using System.Xml.Serialization;
+using System.Xml.Serialization;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Plex;
 using ErsatzTV.Infrastructure.Plex.Models;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Refit;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Infrastructure.Plex
+namespace ErsatzTV.Infrastructure.Plex;
+
+public class PlexServerApiClient : IPlexServerApiClient
 {
-    public class PlexServerApiClient : IPlexServerApiClient
+    private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
+    private readonly ILogger<PlexServerApiClient> _logger;
+
+    public PlexServerApiClient(
+        IFallbackMetadataProvider fallbackMetadataProvider,
+        ILogger<PlexServerApiClient> logger)
     {
-        private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
-        private readonly ILogger<PlexServerApiClient> _logger;
+        _fallbackMetadataProvider = fallbackMetadataProvider;
+        _logger = logger;
+    }
 
-        public PlexServerApiClient(
-            IFallbackMetadataProvider fallbackMetadataProvider,
-            ILogger<PlexServerApiClient> logger)
+    public async Task<bool> Ping(
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
         {
-            _fallbackMetadataProvider = fallbackMetadataProvider;
-            _logger = logger;
-        }
-
-        public async Task<bool> Ping(
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = RestService.For<IPlexServerApi>(
-                    new HttpClient
-                    {
-                        BaseAddress = new Uri(connection.Uri),
-                        Timeout = TimeSpan.FromSeconds(5)
-                    });
-
-                await service.Ping(token.AuthToken);
-                return true;
-            }
-            catch (Exception)
-            {
-                return false;
-            }
-        }
-
-        public async Task<Either<BaseError, List<PlexLibrary>>> GetLibraries(
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = RestService.For<IPlexServerApi>(
-                    new HttpClient
-                    {
-                        BaseAddress = new Uri(connection.Uri),
-                        Timeout = TimeSpan.FromSeconds(10)
-                    });
-                List<PlexLibraryResponse> directory =
-                    await service.GetLibraries(token.AuthToken).Map(r => r.MediaContainer.Directory);
-                return directory
-                    // .Filter(l => l.Hidden == 0)
-                    .Filter(l => l.Type.ToLowerInvariant() is "movie" or "show")
-                    .Map(Project)
-                    .Somes()
-                    .ToList();
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public async Task<Either<BaseError, List<PlexMovie>>> GetMovieLibraryContents(
-            PlexLibrary library,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = RestService.For<IPlexServerApi>(connection.Uri);
-                return await service.GetLibrarySectionContents(library.Key, token.AuthToken)
-                    .Map(r => r.MediaContainer.Metadata.Filter(m => m.Media.Count > 0 && m.Media[0].Part.Count > 0))
-                    .Map(list => list.Map(metadata => ProjectToMovie(metadata, library.MediaSourceId)).ToList());
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public async Task<Either<BaseError, List<PlexShow>>> GetShowLibraryContents(
-            PlexLibrary library,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = RestService.For<IPlexServerApi>(connection.Uri);
-                return await service.GetLibrarySectionContents(library.Key, token.AuthToken)
-                    .Map(r => r.MediaContainer.Metadata)
-                    .Map(list => list.Map(metadata => ProjectToShow(metadata, library.MediaSourceId)).ToList());
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public async Task<Either<BaseError, List<PlexSeason>>> GetShowSeasons(
-            PlexLibrary library,
-            PlexShow show,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = XmlServiceFor(connection.Uri);
-                return await service.GetShowChildren(show.Key.Split("/").Reverse().Skip(1).Head(), token.AuthToken)
-                    .Map(r => r.Metadata)
-                    .Map(list => list.Map(metadata => ProjectToSeason(metadata, library.MediaSourceId)).ToList());
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public async Task<Either<BaseError, List<PlexEpisode>>> GetSeasonEpisodes(
-            PlexLibrary library,
-            PlexSeason season,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = XmlServiceFor(connection.Uri);
-                return await service.GetSeasonChildren(season.Key.Split("/").Reverse().Skip(1).Head(), token.AuthToken)
-                    .Map(r => r.Metadata.Filter(m => m.Media.Count > 0 && m.Media[0].Part.Count > 0))
-                    .Map(list => list.Map(metadata => ProjectToEpisode(metadata, library.MediaSourceId)))
-                    .Map(ProcessMultiEpisodeFiles);
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public async Task<Either<BaseError, MovieMetadata>> GetMovieMetadata(
-            PlexLibrary library,
-            string key,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = XmlServiceFor(connection.Uri);
-                return await service.GetVideoMetadata(key, token.AuthToken)
-                    .Map(Optional)
-                    .Map(
-                        r => r.Filter(m => m.Metadata.Media.Count > 0 && m.Metadata.Media[0].Part.Count > 0)
-                            .HeadOrNone())
-                    .MapT(response => ProjectToMovieMetadata(response.Metadata, library.MediaSourceId))
-                    .Map(o => o.ToEither<BaseError>("Unable to locate metadata"));
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public async Task<Either<BaseError, ShowMetadata>> GetShowMetadata(
-            PlexLibrary library,
-            string key,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = XmlServiceFor(connection.Uri);
-                return await service.GetDirectoryMetadata(key, token.AuthToken)
-                    .Map(Optional)
-                    .MapT(response => ProjectToShowMetadata(response.Metadata, library.MediaSourceId))
-                    .Map(o => o.ToEither<BaseError>("Unable to locate metadata"));
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public async Task<Either<BaseError, Tuple<MovieMetadata, MediaVersion>>> GetMovieMetadataAndStatistics(
-            PlexLibrary library,
-            string key,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = XmlServiceFor(connection.Uri);
-                Option<PlexXmlVideoMetadataResponseContainer> maybeResponse = await service
-                    .GetVideoMetadata(key, token.AuthToken)
-                    .Map(Optional)
-                    .Map(
-                        r => r.Filter(m => m.Metadata.Media.Count > 0 && m.Metadata.Media[0].Part.Count > 0)
-                            .HeadOrNone());
-                return maybeResponse.Match(
-                    response =>
-                    {
-                        Option<MediaVersion> maybeVersion = ProjectToMediaVersion(response.Metadata);
-                        return maybeVersion.Match<Either<BaseError, Tuple<MovieMetadata, MediaVersion>>>(
-                            version => Tuple(ProjectToMovieMetadata(response.Metadata, library.MediaSourceId), version),
-                            () => BaseError.New("Unable to locate metadata"));
-                    },
-                    () => BaseError.New("Unable to locate metadata"));
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        public async Task<Either<BaseError, Tuple<EpisodeMetadata, MediaVersion>>> GetEpisodeMetadataAndStatistics(
-            PlexLibrary library,
-            string key,
-            PlexConnection connection,
-            PlexServerAuthToken token)
-        {
-            try
-            {
-                IPlexServerApi service = XmlServiceFor(connection.Uri);
-                Option<PlexXmlVideoMetadataResponseContainer> maybeResponse = await service
-                    .GetVideoMetadata(key, token.AuthToken)
-                    .Map(Optional)
-                    .Map(
-                        r => r.Filter(m => m.Metadata.Media.Count > 0 && m.Metadata.Media[0].Part.Count > 0)
-                            .HeadOrNone());
-                return maybeResponse.Match(
-                    response =>
-                    {
-                        Option<MediaVersion> maybeVersion = ProjectToMediaVersion(response.Metadata);
-                        return maybeVersion.Match<Either<BaseError, Tuple<EpisodeMetadata, MediaVersion>>>(
-                            version => Tuple(
-                                ProjectToEpisodeMetadata(response.Metadata, library.MediaSourceId),
-                                version),
-                            () => BaseError.New("Unable to locate metadata"));
-                    },
-                    () => BaseError.New("Unable to locate metadata"));
-            }
-            catch (Exception ex)
-            {
-                return BaseError.New(ex.ToString());
-            }
-        }
-
-        private List<PlexEpisode> ProcessMultiEpisodeFiles(IEnumerable<PlexEpisode> episodes)
-        {
-            // add all metadata from duplicate paths to first entry with given path
-            // i.e. s1e1 episode will add s1e2 metadata if s1e1 and s1e2 have same physical path
-            var result = new Dictionary<string, PlexEpisode>();
-            foreach (PlexEpisode episode in episodes.OrderBy(e => e.EpisodeMetadata.Head().EpisodeNumber))
-            {
-                string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
-                if (result.TryGetValue(path, out PlexEpisode existing))
+            IPlexServerApi service = RestService.For<IPlexServerApi>(
+                new HttpClient
                 {
-                    existing.EpisodeMetadata.Add(episode.EpisodeMetadata.Head());
-                }
-                else
-                {
-                    result.Add(path, episode);
-                }
-            }
-
-            return result.Values.ToList();
-        }
-
-        private static IPlexServerApi XmlServiceFor(string uri)
-        {
-            var overrides = new XmlAttributeOverrides();
-            var attrs = new XmlAttributes { XmlIgnore = true };
-            overrides.Add(typeof(PlexMetadataResponse), "Media", attrs);
-
-            return RestService.For<IPlexServerApi>(
-                uri,
-                new RefitSettings
-                {
-                    ContentSerializer = new XmlContentSerializer(
-                        new XmlContentSerializerSettings
-                        {
-                            XmlAttributeOverrides = overrides
-                        })
+                    BaseAddress = new Uri(connection.Uri),
+                    Timeout = TimeSpan.FromSeconds(5)
                 });
+
+            await service.Ping(token.AuthToken);
+            return true;
         }
-
-        private static Option<PlexLibrary> Project(PlexLibraryResponse response) =>
-            response.Type switch
-            {
-                "show" => new PlexLibrary
-                {
-                    Key = response.Key,
-                    Name = response.Title,
-                    MediaKind = LibraryMediaKind.Shows,
-                    ShouldSyncItems = false,
-                    Paths = new List<LibraryPath> { new() { Path = $"plex://{response.Uuid}" } }
-                },
-                "movie" => new PlexLibrary
-                {
-                    Key = response.Key,
-                    Name = response.Title,
-                    MediaKind = LibraryMediaKind.Movies,
-                    ShouldSyncItems = false,
-                    Paths = new List<LibraryPath> { new() { Path = $"plex://{response.Uuid}" } }
-                },
-                // TODO: "artist" for music libraries
-                _ => None
-            };
-
-        private PlexMovie ProjectToMovie(PlexMetadataResponse response, int mediaSourceId)
+        catch (Exception)
         {
-            PlexMediaResponse<PlexPartResponse> media = response.Media.Head();
-            PlexPartResponse part = media.Part.Head();
-            DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
-            DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
-
-            MovieMetadata metadata = ProjectToMovieMetadata(response, mediaSourceId);
-
-            var version = new MediaVersion
-            {
-                Name = "Main",
-                Duration = TimeSpan.FromMilliseconds(media.Duration),
-                Width = media.Width,
-                Height = media.Height,
-                // specifically omit sample aspect ratio
-                DateAdded = dateAdded,
-                DateUpdated = lastWriteTime,
-                MediaFiles = new List<MediaFile>
-                {
-                    new PlexMediaFile
-                    {
-                        PlexId = part.Id,
-                        Key = part.Key,
-                        Path = part.File
-                    }
-                },
-                Streams = new List<MediaStream>()
-            };
-
-            var movie = new PlexMovie
-            {
-                Key = response.Key,
-                MovieMetadata = new List<MovieMetadata> { metadata },
-                MediaVersions = new List<MediaVersion> { version },
-                TraktListItems = new List<TraktListItem>()
-            };
-
-            return movie;
+            return false;
         }
+    }
 
-        private MovieMetadata ProjectToMovieMetadata(PlexMetadataResponse response, int mediaSourceId)
+    public async Task<Either<BaseError, List<PlexLibrary>>> GetLibraries(
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
         {
-            DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
-            DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
-
-            var metadata = new MovieMetadata
-            {
-                MetadataKind = MetadataKind.External,
-                Title = response.Title,
-                SortTitle = _fallbackMetadataProvider.GetSortTitle(response.Title),
-                Plot = response.Summary,
-                Year = response.Year,
-                Tagline = response.Tagline,
-                ContentRating = response.ContentRating,
-                DateAdded = dateAdded,
-                DateUpdated = lastWriteTime,
-                Genres = Optional(response.Genre).Flatten().Map(g => new Genre { Name = g.Tag }).ToList(),
-                Tags = new List<Tag>(),
-                Studios = new List<Studio>(),
-                Actors = Optional(response.Role).Flatten().Map(r => ProjectToModel(r, dateAdded, lastWriteTime))
-                    .ToList(),
-                Directors = Optional(response.Director).Flatten().Map(d => new Director { Name = d.Tag }).ToList(),
-                Writers = Optional(response.Writer).Flatten().Map(w => new Writer { Name = w.Tag }).ToList()
-            };
-
-            if (response is PlexXmlMetadataResponse xml)
-            {
-                metadata.Guids = Optional(xml.Guid).Flatten().Map(g => new MetadataGuid { Guid = g.Id }).ToList();
-                if (!string.IsNullOrWhiteSpace(xml.PlexGuid))
+            IPlexServerApi service = RestService.For<IPlexServerApi>(
+                new HttpClient
                 {
-                    Option<string> normalized = NormalizeGuid(xml.PlexGuid);
-                    foreach (string guid in normalized)
-                    {
-                        if (metadata.Guids.All(g => g.Guid != guid))
-                        {
-                            metadata.Guids.Add(new MetadataGuid { Guid = guid });
-                        }
-                    }
-                }
+                    BaseAddress = new Uri(connection.Uri),
+                    Timeout = TimeSpan.FromSeconds(10)
+                });
+            List<PlexLibraryResponse> directory =
+                await service.GetLibraries(token.AuthToken).Map(r => r.MediaContainer.Directory);
+            return directory
+                // .Filter(l => l.Hidden == 0)
+                .Filter(l => l.Type.ToLowerInvariant() is "movie" or "show")
+                .Map(Project)
+                .Somes()
+                .ToList();
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public async Task<Either<BaseError, List<PlexMovie>>> GetMovieLibraryContents(
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = RestService.For<IPlexServerApi>(connection.Uri);
+            return await service.GetLibrarySectionContents(library.Key, token.AuthToken)
+                .Map(r => r.MediaContainer.Metadata.Filter(m => m.Media.Count > 0 && m.Media[0].Part.Count > 0))
+                .Map(list => list.Map(metadata => ProjectToMovie(metadata, library.MediaSourceId)).ToList());
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public async Task<Either<BaseError, List<PlexShow>>> GetShowLibraryContents(
+        PlexLibrary library,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = RestService.For<IPlexServerApi>(connection.Uri);
+            return await service.GetLibrarySectionContents(library.Key, token.AuthToken)
+                .Map(r => r.MediaContainer.Metadata)
+                .Map(list => list.Map(metadata => ProjectToShow(metadata, library.MediaSourceId)).ToList());
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public async Task<Either<BaseError, List<PlexSeason>>> GetShowSeasons(
+        PlexLibrary library,
+        PlexShow show,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = XmlServiceFor(connection.Uri);
+            return await service.GetShowChildren(show.Key.Split("/").Reverse().Skip(1).Head(), token.AuthToken)
+                .Map(r => r.Metadata)
+                .Map(list => list.Map(metadata => ProjectToSeason(metadata, library.MediaSourceId)).ToList());
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public async Task<Either<BaseError, List<PlexEpisode>>> GetSeasonEpisodes(
+        PlexLibrary library,
+        PlexSeason season,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = XmlServiceFor(connection.Uri);
+            return await service.GetSeasonChildren(season.Key.Split("/").Reverse().Skip(1).Head(), token.AuthToken)
+                .Map(r => r.Metadata.Filter(m => m.Media.Count > 0 && m.Media[0].Part.Count > 0))
+                .Map(list => list.Map(metadata => ProjectToEpisode(metadata, library.MediaSourceId)))
+                .Map(ProcessMultiEpisodeFiles);
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public async Task<Either<BaseError, MovieMetadata>> GetMovieMetadata(
+        PlexLibrary library,
+        string key,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = XmlServiceFor(connection.Uri);
+            return await service.GetVideoMetadata(key, token.AuthToken)
+                .Map(Optional)
+                .Map(
+                    r => r.Filter(m => m.Metadata.Media.Count > 0 && m.Metadata.Media[0].Part.Count > 0)
+                        .HeadOrNone())
+                .MapT(response => ProjectToMovieMetadata(response.Metadata, library.MediaSourceId))
+                .Map(o => o.ToEither<BaseError>("Unable to locate metadata"));
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public async Task<Either<BaseError, ShowMetadata>> GetShowMetadata(
+        PlexLibrary library,
+        string key,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = XmlServiceFor(connection.Uri);
+            return await service.GetDirectoryMetadata(key, token.AuthToken)
+                .Map(Optional)
+                .MapT(response => ProjectToShowMetadata(response.Metadata, library.MediaSourceId))
+                .Map(o => o.ToEither<BaseError>("Unable to locate metadata"));
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public async Task<Either<BaseError, Tuple<MovieMetadata, MediaVersion>>> GetMovieMetadataAndStatistics(
+        PlexLibrary library,
+        string key,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = XmlServiceFor(connection.Uri);
+            Option<PlexXmlVideoMetadataResponseContainer> maybeResponse = await service
+                .GetVideoMetadata(key, token.AuthToken)
+                .Map(Optional)
+                .Map(
+                    r => r.Filter(m => m.Metadata.Media.Count > 0 && m.Metadata.Media[0].Part.Count > 0)
+                        .HeadOrNone());
+            return maybeResponse.Match(
+                response =>
+                {
+                    Option<MediaVersion> maybeVersion = ProjectToMediaVersion(response.Metadata);
+                    return maybeVersion.Match<Either<BaseError, Tuple<MovieMetadata, MediaVersion>>>(
+                        version => Tuple(ProjectToMovieMetadata(response.Metadata, library.MediaSourceId), version),
+                        () => BaseError.New("Unable to locate metadata"));
+                },
+                () => BaseError.New("Unable to locate metadata"));
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    public async Task<Either<BaseError, Tuple<EpisodeMetadata, MediaVersion>>> GetEpisodeMetadataAndStatistics(
+        PlexLibrary library,
+        string key,
+        PlexConnection connection,
+        PlexServerAuthToken token)
+    {
+        try
+        {
+            IPlexServerApi service = XmlServiceFor(connection.Uri);
+            Option<PlexXmlVideoMetadataResponseContainer> maybeResponse = await service
+                .GetVideoMetadata(key, token.AuthToken)
+                .Map(Optional)
+                .Map(
+                    r => r.Filter(m => m.Metadata.Media.Count > 0 && m.Metadata.Media[0].Part.Count > 0)
+                        .HeadOrNone());
+            return maybeResponse.Match(
+                response =>
+                {
+                    Option<MediaVersion> maybeVersion = ProjectToMediaVersion(response.Metadata);
+                    return maybeVersion.Match<Either<BaseError, Tuple<EpisodeMetadata, MediaVersion>>>(
+                        version => Tuple(
+                            ProjectToEpisodeMetadata(response.Metadata, library.MediaSourceId),
+                            version),
+                        () => BaseError.New("Unable to locate metadata"));
+                },
+                () => BaseError.New("Unable to locate metadata"));
+        }
+        catch (Exception ex)
+        {
+            return BaseError.New(ex.ToString());
+        }
+    }
+
+    private List<PlexEpisode> ProcessMultiEpisodeFiles(IEnumerable<PlexEpisode> episodes)
+    {
+        // add all metadata from duplicate paths to first entry with given path
+        // i.e. s1e1 episode will add s1e2 metadata if s1e1 and s1e2 have same physical path
+        var result = new Dictionary<string, PlexEpisode>();
+        foreach (PlexEpisode episode in episodes.OrderBy(e => e.EpisodeMetadata.Head().EpisodeNumber))
+        {
+            string path = episode.MediaVersions.Head().MediaFiles.Head().Path;
+            if (result.TryGetValue(path, out PlexEpisode existing))
+            {
+                existing.EpisodeMetadata.Add(episode.EpisodeMetadata.Head());
             }
             else
             {
-                metadata.Guids = new List<MetadataGuid>();
+                result.Add(path, episode);
             }
-
-            if (!string.IsNullOrWhiteSpace(response.Studio))
-            {
-                metadata.Studios.Add(new Studio { Name = response.Studio });
-            }
-
-            if (DateTime.TryParse(response.OriginallyAvailableAt, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
-            if (!string.IsNullOrWhiteSpace(response.Thumb))
-            {
-                var path = $"plex/{mediaSourceId}{response.Thumb}";
-                var artwork = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Poster,
-                    Path = path,
-                    DateAdded = dateAdded,
-                    DateUpdated = lastWriteTime
-                };
-
-                metadata.Artwork ??= new List<Artwork>();
-                metadata.Artwork.Add(artwork);
-            }
-
-            if (!string.IsNullOrWhiteSpace(response.Art))
-            {
-                var path = $"plex/{mediaSourceId}{response.Art}";
-                var artwork = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.FanArt,
-                    Path = path,
-                    DateAdded = dateAdded,
-                    DateUpdated = lastWriteTime
-                };
-
-                metadata.Artwork ??= new List<Artwork>();
-                metadata.Artwork.Add(artwork);
-            }
-
-            return metadata;
         }
 
-        private Option<MediaVersion> ProjectToMediaVersion(PlexXmlMetadataResponse response)
+        return result.Values.ToList();
+    }
+
+    private static IPlexServerApi XmlServiceFor(string uri)
+    {
+        var overrides = new XmlAttributeOverrides();
+        var attrs = new XmlAttributes { XmlIgnore = true };
+        overrides.Add(typeof(PlexMetadataResponse), "Media", attrs);
+
+        return RestService.For<IPlexServerApi>(
+            uri,
+            new RefitSettings
+            {
+                ContentSerializer = new XmlContentSerializer(
+                    new XmlContentSerializerSettings
+                    {
+                        XmlAttributeOverrides = overrides
+                    })
+            });
+    }
+
+    private static Option<PlexLibrary> Project(PlexLibraryResponse response) =>
+        response.Type switch
         {
-            List<PlexStreamResponse> streams = response.Media.Head().Part.Head().Stream;
-            DateTime dateUpdated = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
-            Option<PlexStreamResponse> maybeVideoStream = streams.Find(s => s.StreamType == 1);
-            return maybeVideoStream.Map(
-                videoStream =>
-                {
-                    var version = new MediaVersion
-                    {
-                        SampleAspectRatio = videoStream.PixelAspectRatio ?? "1:1",
-                        VideoScanKind = videoStream.ScanType switch
-                        {
-                            "interlaced" => VideoScanKind.Interlaced,
-                            "progressive" => VideoScanKind.Progressive,
-                            _ => VideoScanKind.Unknown
-                        },
-                        Streams = new List<MediaStream>(),
-                        DateUpdated = dateUpdated
-                    };
-
-                    version.Streams.Add(
-                        new MediaStream
-                        {
-                            MediaStreamKind = MediaStreamKind.Video,
-                            Index = videoStream.Index,
-                            Codec = videoStream.Codec,
-                            Profile = (videoStream.Profile ?? string.Empty).ToLowerInvariant(),
-                            Default = videoStream.Default,
-                            Language = videoStream.LanguageCode,
-                            Forced = videoStream.Forced
-                        });
-
-                    foreach (PlexStreamResponse audioStream in streams.Filter(s => s.StreamType == 2))
-                    {
-                        var stream = new MediaStream
-                        {
-                            MediaVersionId = version.Id,
-                            MediaStreamKind = MediaStreamKind.Audio,
-                            Index = audioStream.Index,
-                            Codec = audioStream.Codec,
-                            Profile = (audioStream.Profile ?? string.Empty).ToLowerInvariant(),
-                            Channels = audioStream.Channels,
-                            Default = audioStream.Default,
-                            Forced = audioStream.Forced,
-                            Language = audioStream.LanguageCode
-                        };
-
-                        version.Streams.Add(stream);
-                    }
-
-                    foreach (PlexStreamResponse subtitleStream in streams.Filter(s => s.StreamType == 3))
-                    {
-                        var stream = new MediaStream
-                        {
-                            MediaVersionId = version.Id,
-                            MediaStreamKind = MediaStreamKind.Subtitle,
-                            Index = subtitleStream.Index,
-                            Codec = subtitleStream.Codec,
-                            Default = subtitleStream.Default,
-                            Forced = subtitleStream.Forced,
-                            Language = subtitleStream.LanguageCode
-                        };
-
-                        version.Streams.Add(stream);
-                    }
-
-                    return version;
-                });
-        }
-
-        private PlexShow ProjectToShow(PlexMetadataResponse response, int mediaSourceId)
-        {
-            ShowMetadata metadata = ProjectToShowMetadata(response, mediaSourceId);
-
-            var show = new PlexShow
+            "show" => new PlexLibrary
             {
                 Key = response.Key,
-                ShowMetadata = new List<ShowMetadata> { metadata },
-                TraktListItems = new List<TraktListItem>()
-            };
+                Name = response.Title,
+                MediaKind = LibraryMediaKind.Shows,
+                ShouldSyncItems = false,
+                Paths = new List<LibraryPath> { new() { Path = $"plex://{response.Uuid}" } }
+            },
+            "movie" => new PlexLibrary
+            {
+                Key = response.Key,
+                Name = response.Title,
+                MediaKind = LibraryMediaKind.Movies,
+                ShouldSyncItems = false,
+                Paths = new List<LibraryPath> { new() { Path = $"plex://{response.Uuid}" } }
+            },
+            // TODO: "artist" for music libraries
+            _ => None
+        };
 
-            return show;
-        }
+    private PlexMovie ProjectToMovie(PlexMetadataResponse response, int mediaSourceId)
+    {
+        PlexMediaResponse<PlexPartResponse> media = response.Media.Head();
+        PlexPartResponse part = media.Part.Head();
+        DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
+        DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
 
-        private ShowMetadata ProjectToShowMetadata(PlexMetadataResponse response, int mediaSourceId)
+        MovieMetadata metadata = ProjectToMovieMetadata(response, mediaSourceId);
+
+        var version = new MediaVersion
         {
-            DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
-            DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
-
-            var metadata = new ShowMetadata
+            Name = "Main",
+            Duration = TimeSpan.FromMilliseconds(media.Duration),
+            Width = media.Width,
+            Height = media.Height,
+            // specifically omit sample aspect ratio
+            DateAdded = dateAdded,
+            DateUpdated = lastWriteTime,
+            MediaFiles = new List<MediaFile>
             {
-                MetadataKind = MetadataKind.External,
-                Title = response.Title,
-                SortTitle = _fallbackMetadataProvider.GetSortTitle(response.Title),
-                Plot = response.Summary,
-                Year = response.Year,
-                Tagline = response.Tagline,
-                ContentRating = response.ContentRating,
-                DateAdded = dateAdded,
-                DateUpdated = lastWriteTime,
-                Genres = Optional(response.Genre).Flatten().Map(g => new Genre { Name = g.Tag }).ToList(),
-                Tags = new List<Tag>(),
-                Studios = new List<Studio>(),
-                Actors = Optional(response.Role).Flatten().Map(r => ProjectToModel(r, dateAdded, lastWriteTime))
-                    .ToList()
-            };
-
-            if (response is PlexXmlMetadataResponse xml)
-            {
-                metadata.Guids = Optional(xml.Guid).Flatten().Map(g => new MetadataGuid { Guid = g.Id }).ToList();
-                if (!string.IsNullOrWhiteSpace(xml.PlexGuid))
+                new PlexMediaFile
                 {
-                    Option<string> normalized = NormalizeGuid(xml.PlexGuid);
-                    foreach (string guid in normalized)
-                    {
-                        if (metadata.Guids.All(g => g.Guid != guid))
-                        {
-                            metadata.Guids.Add(new MetadataGuid { Guid = guid });
-                        }
-                    }
+                    PlexId = part.Id,
+                    Key = part.Key,
+                    Path = part.File
                 }
-            }
-            else
-            {
-                metadata.Guids = new List<MetadataGuid>();
-            }
+            },
+            Streams = new List<MediaStream>()
+        };
 
-            if (!string.IsNullOrWhiteSpace(response.Studio))
-            {
-                metadata.Studios.Add(new Studio { Name = response.Studio });
-            }
-
-            if (DateTime.TryParse(response.OriginallyAvailableAt, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
-            if (!string.IsNullOrWhiteSpace(response.Thumb))
-            {
-                var path = $"plex/{mediaSourceId}{response.Thumb}";
-                var artwork = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Poster,
-                    Path = path,
-                    DateAdded = dateAdded,
-                    DateUpdated = lastWriteTime
-                };
-
-                metadata.Artwork ??= new List<Artwork>();
-                metadata.Artwork.Add(artwork);
-            }
-
-            if (!string.IsNullOrWhiteSpace(response.Art))
-            {
-                var path = $"plex/{mediaSourceId}{response.Art}";
-                var artwork = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.FanArt,
-                    Path = path,
-                    DateAdded = dateAdded,
-                    DateUpdated = lastWriteTime
-                };
-
-                metadata.Artwork ??= new List<Artwork>();
-                metadata.Artwork.Add(artwork);
-            }
-
-            return metadata;
-        }
-
-        private PlexSeason ProjectToSeason(PlexXmlMetadataResponse response, int mediaSourceId)
+        var movie = new PlexMovie
         {
-            DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
-            DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
+            Key = response.Key,
+            MovieMetadata = new List<MovieMetadata> { metadata },
+            MediaVersions = new List<MediaVersion> { version },
+            TraktListItems = new List<TraktListItem>()
+        };
 
-            var metadata = new SeasonMetadata
-            {
-                MetadataKind = MetadataKind.External,
-                Title = response.Title,
-                SortTitle = _fallbackMetadataProvider.GetSortTitle(response.Title),
-                Year = response.Year,
-                DateAdded = dateAdded,
-                DateUpdated = lastWriteTime
-            };
+        return movie;
+    }
 
-            metadata.Guids = Optional(response.Guid).Flatten().Map(g => new MetadataGuid { Guid = g.Id }).ToList();
-            if (!string.IsNullOrWhiteSpace(response.PlexGuid))
+    private MovieMetadata ProjectToMovieMetadata(PlexMetadataResponse response, int mediaSourceId)
+    {
+        DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
+        DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
+
+        var metadata = new MovieMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = response.Title,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(response.Title),
+            Plot = response.Summary,
+            Year = response.Year,
+            Tagline = response.Tagline,
+            ContentRating = response.ContentRating,
+            DateAdded = dateAdded,
+            DateUpdated = lastWriteTime,
+            Genres = Optional(response.Genre).Flatten().Map(g => new Genre { Name = g.Tag }).ToList(),
+            Tags = new List<Tag>(),
+            Studios = new List<Studio>(),
+            Actors = Optional(response.Role).Flatten().Map(r => ProjectToModel(r, dateAdded, lastWriteTime))
+                .ToList(),
+            Directors = Optional(response.Director).Flatten().Map(d => new Director { Name = d.Tag }).ToList(),
+            Writers = Optional(response.Writer).Flatten().Map(w => new Writer { Name = w.Tag }).ToList()
+        };
+
+        if (response is PlexXmlMetadataResponse xml)
+        {
+            metadata.Guids = Optional(xml.Guid).Flatten().Map(g => new MetadataGuid { Guid = g.Id }).ToList();
+            if (!string.IsNullOrWhiteSpace(xml.PlexGuid))
             {
-                Option<string> normalized = NormalizeGuid(response.PlexGuid);
+                Option<string> normalized = NormalizeGuid(xml.PlexGuid);
                 foreach (string guid in normalized)
                 {
                     if (metadata.Guids.All(g => g.Guid != guid))
@@ -650,211 +396,457 @@ namespace ErsatzTV.Infrastructure.Plex
                     }
                 }
             }
-
-            if (!string.IsNullOrWhiteSpace(response.Thumb))
-            {
-                var path = $"plex/{mediaSourceId}{response.Thumb}";
-                var artwork = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Poster,
-                    Path = path,
-                    DateAdded = dateAdded,
-                    DateUpdated = lastWriteTime
-                };
-
-                metadata.Artwork ??= new List<Artwork>();
-                metadata.Artwork.Add(artwork);
-            }
-
-            if (!string.IsNullOrWhiteSpace(response.Art))
-            {
-                var path = $"plex/{mediaSourceId}{response.Art}";
-                var artwork = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.FanArt,
-                    Path = path,
-                    DateAdded = dateAdded,
-                    DateUpdated = lastWriteTime
-                };
-
-                metadata.Artwork ??= new List<Artwork>();
-                metadata.Artwork.Add(artwork);
-            }
-
-            var season = new PlexSeason
-            {
-                Key = response.Key,
-                SeasonNumber = response.Index,
-                SeasonMetadata = new List<SeasonMetadata> { metadata },
-                TraktListItems = new List<TraktListItem>()
-            };
-
-            return season;
+        }
+        else
+        {
+            metadata.Guids = new List<MetadataGuid>();
         }
 
-        private PlexEpisode ProjectToEpisode(PlexXmlMetadataResponse response, int mediaSourceId)
+        if (!string.IsNullOrWhiteSpace(response.Studio))
         {
-            PlexMediaResponse<PlexXmlPartResponse> media = response.Media.Head();
-            PlexXmlPartResponse part = media.Part.Head();
-            DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
-            DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
-
-            EpisodeMetadata metadata = ProjectToEpisodeMetadata(response, mediaSourceId);
-            var version = new MediaVersion
-            {
-                Name = "Main",
-                Duration = TimeSpan.FromMilliseconds(media.Duration),
-                Width = media.Width,
-                Height = media.Height,
-                DateAdded = dateAdded,
-                DateUpdated = lastWriteTime,
-                MediaFiles = new List<MediaFile>
-                {
-                    new PlexMediaFile
-                    {
-                        PlexId = part.Id,
-                        Key = part.Key,
-                        Path = part.File
-                    }
-                },
-                // specifically omit stream details
-                Streams = new List<MediaStream>()
-            };
-
-            var episode = new PlexEpisode
-            {
-                Key = response.Key,
-                EpisodeMetadata = new List<EpisodeMetadata> { metadata },
-                MediaVersions = new List<MediaVersion> { version },
-                TraktListItems = new List<TraktListItem>()
-            };
-
-            return episode;
+            metadata.Studios.Add(new Studio { Name = response.Studio });
         }
 
-        private EpisodeMetadata ProjectToEpisodeMetadata(PlexMetadataResponse response, int mediaSourceId)
+        if (DateTime.TryParse(response.OriginallyAvailableAt, out DateTime releaseDate))
         {
-            DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
-            DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
+            metadata.ReleaseDate = releaseDate;
+        }
 
-            var metadata = new EpisodeMetadata
+        if (!string.IsNullOrWhiteSpace(response.Thumb))
+        {
+            var path = $"plex/{mediaSourceId}{response.Thumb}";
+            var artwork = new Artwork
             {
-                MetadataKind = MetadataKind.External,
-                Title = response.Title,
-                SortTitle = _fallbackMetadataProvider.GetSortTitle(response.Title),
-                EpisodeNumber = response.Index,
-                Plot = response.Summary,
-                Year = response.Year,
-                Tagline = response.Tagline,
+                ArtworkKind = ArtworkKind.Poster,
+                Path = path,
                 DateAdded = dateAdded,
-                DateUpdated = lastWriteTime,
-                Actors = Optional(response.Role).Flatten().Map(r => ProjectToModel(r, dateAdded, lastWriteTime))
-                    .ToList(),
-                Directors = Optional(response.Director).Flatten().Map(d => new Director { Name = d.Tag }).ToList(),
-                Writers = Optional(response.Writer).Flatten().Map(w => new Writer { Name = w.Tag }).ToList()
+                DateUpdated = lastWriteTime
             };
 
-            if (response is PlexXmlMetadataResponse xml)
+            metadata.Artwork ??= new List<Artwork>();
+            metadata.Artwork.Add(artwork);
+        }
+
+        if (!string.IsNullOrWhiteSpace(response.Art))
+        {
+            var path = $"plex/{mediaSourceId}{response.Art}";
+            var artwork = new Artwork
             {
-                metadata.Guids = Optional(xml.Guid).Flatten().Map(g => new MetadataGuid { Guid = g.Id }).ToList();
-                if (!string.IsNullOrWhiteSpace(xml.PlexGuid))
+                ArtworkKind = ArtworkKind.FanArt,
+                Path = path,
+                DateAdded = dateAdded,
+                DateUpdated = lastWriteTime
+            };
+
+            metadata.Artwork ??= new List<Artwork>();
+            metadata.Artwork.Add(artwork);
+        }
+
+        return metadata;
+    }
+
+    private Option<MediaVersion> ProjectToMediaVersion(PlexXmlMetadataResponse response)
+    {
+        List<PlexStreamResponse> streams = response.Media.Head().Part.Head().Stream;
+        DateTime dateUpdated = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
+        Option<PlexStreamResponse> maybeVideoStream = streams.Find(s => s.StreamType == 1);
+        return maybeVideoStream.Map(
+            videoStream =>
+            {
+                var version = new MediaVersion
                 {
-                    Option<string> normalized = NormalizeGuid(xml.PlexGuid);
-                    foreach (string guid in normalized)
+                    SampleAspectRatio = videoStream.PixelAspectRatio ?? "1:1",
+                    VideoScanKind = videoStream.ScanType switch
                     {
-                        if (metadata.Guids.All(g => g.Guid != guid))
-                        {
-                            metadata.Guids.Add(new MetadataGuid { Guid = guid });
-                        }
+                        "interlaced" => VideoScanKind.Interlaced,
+                        "progressive" => VideoScanKind.Progressive,
+                        _ => VideoScanKind.Unknown
+                    },
+                    Streams = new List<MediaStream>(),
+                    DateUpdated = dateUpdated
+                };
+
+                version.Streams.Add(
+                    new MediaStream
+                    {
+                        MediaStreamKind = MediaStreamKind.Video,
+                        Index = videoStream.Index,
+                        Codec = videoStream.Codec,
+                        Profile = (videoStream.Profile ?? string.Empty).ToLowerInvariant(),
+                        Default = videoStream.Default,
+                        Language = videoStream.LanguageCode,
+                        Forced = videoStream.Forced
+                    });
+
+                foreach (PlexStreamResponse audioStream in streams.Filter(s => s.StreamType == 2))
+                {
+                    var stream = new MediaStream
+                    {
+                        MediaVersionId = version.Id,
+                        MediaStreamKind = MediaStreamKind.Audio,
+                        Index = audioStream.Index,
+                        Codec = audioStream.Codec,
+                        Profile = (audioStream.Profile ?? string.Empty).ToLowerInvariant(),
+                        Channels = audioStream.Channels,
+                        Default = audioStream.Default,
+                        Forced = audioStream.Forced,
+                        Language = audioStream.LanguageCode
+                    };
+
+                    version.Streams.Add(stream);
+                }
+
+                foreach (PlexStreamResponse subtitleStream in streams.Filter(s => s.StreamType == 3))
+                {
+                    var stream = new MediaStream
+                    {
+                        MediaVersionId = version.Id,
+                        MediaStreamKind = MediaStreamKind.Subtitle,
+                        Index = subtitleStream.Index,
+                        Codec = subtitleStream.Codec,
+                        Default = subtitleStream.Default,
+                        Forced = subtitleStream.Forced,
+                        Language = subtitleStream.LanguageCode
+                    };
+
+                    version.Streams.Add(stream);
+                }
+
+                return version;
+            });
+    }
+
+    private PlexShow ProjectToShow(PlexMetadataResponse response, int mediaSourceId)
+    {
+        ShowMetadata metadata = ProjectToShowMetadata(response, mediaSourceId);
+
+        var show = new PlexShow
+        {
+            Key = response.Key,
+            ShowMetadata = new List<ShowMetadata> { metadata },
+            TraktListItems = new List<TraktListItem>()
+        };
+
+        return show;
+    }
+
+    private ShowMetadata ProjectToShowMetadata(PlexMetadataResponse response, int mediaSourceId)
+    {
+        DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
+        DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
+
+        var metadata = new ShowMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = response.Title,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(response.Title),
+            Plot = response.Summary,
+            Year = response.Year,
+            Tagline = response.Tagline,
+            ContentRating = response.ContentRating,
+            DateAdded = dateAdded,
+            DateUpdated = lastWriteTime,
+            Genres = Optional(response.Genre).Flatten().Map(g => new Genre { Name = g.Tag }).ToList(),
+            Tags = new List<Tag>(),
+            Studios = new List<Studio>(),
+            Actors = Optional(response.Role).Flatten().Map(r => ProjectToModel(r, dateAdded, lastWriteTime))
+                .ToList()
+        };
+
+        if (response is PlexXmlMetadataResponse xml)
+        {
+            metadata.Guids = Optional(xml.Guid).Flatten().Map(g => new MetadataGuid { Guid = g.Id }).ToList();
+            if (!string.IsNullOrWhiteSpace(xml.PlexGuid))
+            {
+                Option<string> normalized = NormalizeGuid(xml.PlexGuid);
+                foreach (string guid in normalized)
+                {
+                    if (metadata.Guids.All(g => g.Guid != guid))
+                    {
+                        metadata.Guids.Add(new MetadataGuid { Guid = guid });
                     }
                 }
             }
-            else
-            {
-                metadata.Guids = new List<MetadataGuid>();
-            }
-
-            if (DateTime.TryParse(response.OriginallyAvailableAt, out DateTime releaseDate))
-            {
-                metadata.ReleaseDate = releaseDate;
-            }
-
-            if (!string.IsNullOrWhiteSpace(response.Thumb))
-            {
-                var path = $"plex/{mediaSourceId}{response.Thumb}";
-                var artwork = new Artwork
-                {
-                    ArtworkKind = ArtworkKind.Thumbnail,
-                    Path = path,
-                    DateAdded = dateAdded,
-                    DateUpdated = lastWriteTime
-                };
-
-                metadata.Artwork ??= new List<Artwork>();
-                metadata.Artwork.Add(artwork);
-            }
-
-            return metadata;
         }
-
-        private Actor ProjectToModel(PlexRoleResponse role, DateTime dateAdded, DateTime lastWriteTime)
+        else
         {
-            var actor = new Actor { Name = role.Tag, Role = role.Role };
-            if (!string.IsNullOrWhiteSpace(role.Thumb))
-            {
-                actor.Artwork = new Artwork
-                {
-                    Path = role.Thumb,
-                    ArtworkKind = ArtworkKind.Thumbnail,
-                    DateAdded = dateAdded,
-                    DateUpdated = lastWriteTime
-                };
-            }
-
-            return actor;
+            metadata.Guids = new List<MetadataGuid>();
         }
 
-        private Option<string> NormalizeGuid(string guid)
+        if (!string.IsNullOrWhiteSpace(response.Studio))
         {
-            if (guid.StartsWith("plex://show") ||
-                guid.StartsWith("plex://season") ||
-                guid.StartsWith("plex://episode") ||
-                guid.StartsWith("plex://movie"))
-            {
-                return guid;
-            }
-            
-            if (guid.StartsWith("com.plexapp.agents.imdb"))
-            {
-                string strip1 = guid.Replace("com.plexapp.agents.imdb://", string.Empty);
-                string strip2 = strip1.Split("?").Head();
-                return $"imdb://{strip2}";
-            }
-
-            if (guid.StartsWith("com.plexapp.agents.thetvdb"))
-            {
-                string strip1 = guid.Replace("com.plexapp.agents.thetvdb://", string.Empty);
-                string strip2 = strip1.Split("?").Head();
-                return $"tvdb://{strip2}";
-            }
-
-            if (guid.StartsWith("com.plexapp.agents.themoviedb"))
-            {
-                string strip1 = guid.Replace("com.plexapp.agents.themoviedb://", string.Empty);
-                string strip2 = strip1.Split("?").Head();
-                return $"tmdb://{strip2}";
-            }
-
-            if (guid.StartsWith("local://"))
-            {
-                _logger.LogDebug("Ignoring local Plex guid: {Guid}", guid);
-            }
-            else
-            {
-                _logger.LogWarning("Unsupported guid format from Plex; ignoring: {Guid}", guid);
-            }
-
-            return None;
+            metadata.Studios.Add(new Studio { Name = response.Studio });
         }
+
+        if (DateTime.TryParse(response.OriginallyAvailableAt, out DateTime releaseDate))
+        {
+            metadata.ReleaseDate = releaseDate;
+        }
+
+        if (!string.IsNullOrWhiteSpace(response.Thumb))
+        {
+            var path = $"plex/{mediaSourceId}{response.Thumb}";
+            var artwork = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Poster,
+                Path = path,
+                DateAdded = dateAdded,
+                DateUpdated = lastWriteTime
+            };
+
+            metadata.Artwork ??= new List<Artwork>();
+            metadata.Artwork.Add(artwork);
+        }
+
+        if (!string.IsNullOrWhiteSpace(response.Art))
+        {
+            var path = $"plex/{mediaSourceId}{response.Art}";
+            var artwork = new Artwork
+            {
+                ArtworkKind = ArtworkKind.FanArt,
+                Path = path,
+                DateAdded = dateAdded,
+                DateUpdated = lastWriteTime
+            };
+
+            metadata.Artwork ??= new List<Artwork>();
+            metadata.Artwork.Add(artwork);
+        }
+
+        return metadata;
     }
-}
+
+    private PlexSeason ProjectToSeason(PlexXmlMetadataResponse response, int mediaSourceId)
+    {
+        DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
+        DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
+
+        var metadata = new SeasonMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = response.Title,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(response.Title),
+            Year = response.Year,
+            DateAdded = dateAdded,
+            DateUpdated = lastWriteTime
+        };
+
+        metadata.Guids = Optional(response.Guid).Flatten().Map(g => new MetadataGuid { Guid = g.Id }).ToList();
+        if (!string.IsNullOrWhiteSpace(response.PlexGuid))
+        {
+            Option<string> normalized = NormalizeGuid(response.PlexGuid);
+            foreach (string guid in normalized)
+            {
+                if (metadata.Guids.All(g => g.Guid != guid))
+                {
+                    metadata.Guids.Add(new MetadataGuid { Guid = guid });
+                }
+            }
+        }
+
+        if (!string.IsNullOrWhiteSpace(response.Thumb))
+        {
+            var path = $"plex/{mediaSourceId}{response.Thumb}";
+            var artwork = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Poster,
+                Path = path,
+                DateAdded = dateAdded,
+                DateUpdated = lastWriteTime
+            };
+
+            metadata.Artwork ??= new List<Artwork>();
+            metadata.Artwork.Add(artwork);
+        }
+
+        if (!string.IsNullOrWhiteSpace(response.Art))
+        {
+            var path = $"plex/{mediaSourceId}{response.Art}";
+            var artwork = new Artwork
+            {
+                ArtworkKind = ArtworkKind.FanArt,
+                Path = path,
+                DateAdded = dateAdded,
+                DateUpdated = lastWriteTime
+            };
+
+            metadata.Artwork ??= new List<Artwork>();
+            metadata.Artwork.Add(artwork);
+        }
+
+        var season = new PlexSeason
+        {
+            Key = response.Key,
+            SeasonNumber = response.Index,
+            SeasonMetadata = new List<SeasonMetadata> { metadata },
+            TraktListItems = new List<TraktListItem>()
+        };
+
+        return season;
+    }
+
+    private PlexEpisode ProjectToEpisode(PlexXmlMetadataResponse response, int mediaSourceId)
+    {
+        PlexMediaResponse<PlexXmlPartResponse> media = response.Media.Head();
+        PlexXmlPartResponse part = media.Part.Head();
+        DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
+        DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
+
+        EpisodeMetadata metadata = ProjectToEpisodeMetadata(response, mediaSourceId);
+        var version = new MediaVersion
+        {
+            Name = "Main",
+            Duration = TimeSpan.FromMilliseconds(media.Duration),
+            Width = media.Width,
+            Height = media.Height,
+            DateAdded = dateAdded,
+            DateUpdated = lastWriteTime,
+            MediaFiles = new List<MediaFile>
+            {
+                new PlexMediaFile
+                {
+                    PlexId = part.Id,
+                    Key = part.Key,
+                    Path = part.File
+                }
+            },
+            // specifically omit stream details
+            Streams = new List<MediaStream>()
+        };
+
+        var episode = new PlexEpisode
+        {
+            Key = response.Key,
+            EpisodeMetadata = new List<EpisodeMetadata> { metadata },
+            MediaVersions = new List<MediaVersion> { version },
+            TraktListItems = new List<TraktListItem>()
+        };
+
+        return episode;
+    }
+
+    private EpisodeMetadata ProjectToEpisodeMetadata(PlexMetadataResponse response, int mediaSourceId)
+    {
+        DateTime dateAdded = DateTimeOffset.FromUnixTimeSeconds(response.AddedAt).DateTime;
+        DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
+
+        var metadata = new EpisodeMetadata
+        {
+            MetadataKind = MetadataKind.External,
+            Title = response.Title,
+            SortTitle = _fallbackMetadataProvider.GetSortTitle(response.Title),
+            EpisodeNumber = response.Index,
+            Plot = response.Summary,
+            Year = response.Year,
+            Tagline = response.Tagline,
+            DateAdded = dateAdded,
+            DateUpdated = lastWriteTime,
+            Actors = Optional(response.Role).Flatten().Map(r => ProjectToModel(r, dateAdded, lastWriteTime))
+                .ToList(),
+            Directors = Optional(response.Director).Flatten().Map(d => new Director { Name = d.Tag }).ToList(),
+            Writers = Optional(response.Writer).Flatten().Map(w => new Writer { Name = w.Tag }).ToList()
+        };
+
+        if (response is PlexXmlMetadataResponse xml)
+        {
+            metadata.Guids = Optional(xml.Guid).Flatten().Map(g => new MetadataGuid { Guid = g.Id }).ToList();
+            if (!string.IsNullOrWhiteSpace(xml.PlexGuid))
+            {
+                Option<string> normalized = NormalizeGuid(xml.PlexGuid);
+                foreach (string guid in normalized)
+                {
+                    if (metadata.Guids.All(g => g.Guid != guid))
+                    {
+                        metadata.Guids.Add(new MetadataGuid { Guid = guid });
+                    }
+                }
+            }
+        }
+        else
+        {
+            metadata.Guids = new List<MetadataGuid>();
+        }
+
+        if (DateTime.TryParse(response.OriginallyAvailableAt, out DateTime releaseDate))
+        {
+            metadata.ReleaseDate = releaseDate;
+        }
+
+        if (!string.IsNullOrWhiteSpace(response.Thumb))
+        {
+            var path = $"plex/{mediaSourceId}{response.Thumb}";
+            var artwork = new Artwork
+            {
+                ArtworkKind = ArtworkKind.Thumbnail,
+                Path = path,
+                DateAdded = dateAdded,
+                DateUpdated = lastWriteTime
+            };
+
+            metadata.Artwork ??= new List<Artwork>();
+            metadata.Artwork.Add(artwork);
+        }
+
+        return metadata;
+    }
+
+    private Actor ProjectToModel(PlexRoleResponse role, DateTime dateAdded, DateTime lastWriteTime)
+    {
+        var actor = new Actor { Name = role.Tag, Role = role.Role };
+        if (!string.IsNullOrWhiteSpace(role.Thumb))
+        {
+            actor.Artwork = new Artwork
+            {
+                Path = role.Thumb,
+                ArtworkKind = ArtworkKind.Thumbnail,
+                DateAdded = dateAdded,
+                DateUpdated = lastWriteTime
+            };
+        }
+
+        return actor;
+    }
+
+    private Option<string> NormalizeGuid(string guid)
+    {
+        if (guid.StartsWith("plex://show") ||
+            guid.StartsWith("plex://season") ||
+            guid.StartsWith("plex://episode") ||
+            guid.StartsWith("plex://movie"))
+        {
+            return guid;
+        }
+            
+        if (guid.StartsWith("com.plexapp.agents.imdb"))
+        {
+            string strip1 = guid.Replace("com.plexapp.agents.imdb://", string.Empty);
+            string strip2 = strip1.Split("?").Head();
+            return $"imdb://{strip2}";
+        }
+
+        if (guid.StartsWith("com.plexapp.agents.thetvdb"))
+        {
+            string strip1 = guid.Replace("com.plexapp.agents.thetvdb://", string.Empty);
+            string strip2 = strip1.Split("?").Head();
+            return $"tvdb://{strip2}";
+        }
+
+        if (guid.StartsWith("com.plexapp.agents.themoviedb"))
+        {
+            string strip1 = guid.Replace("com.plexapp.agents.themoviedb://", string.Empty);
+            string strip2 = strip1.Split("?").Head();
+            return $"tmdb://{strip2}";
+        }
+
+        if (guid.StartsWith("local://"))
+        {
+            _logger.LogDebug("Ignoring local Plex guid: {Guid}", guid);
+        }
+        else
+        {
+            _logger.LogWarning("Unsupported guid format from Plex; ignoring: {Guid}", guid);
+        }
+
+        return None;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Plex/PlexTvApiClient.cs b/ErsatzTV.Infrastructure/Plex/PlexTvApiClient.cs
index 459e720aa..f36f937c1 100644
--- a/ErsatzTV.Infrastructure/Plex/PlexTvApiClient.cs
+++ b/ErsatzTV.Infrastructure/Plex/PlexTvApiClient.cs
@@ -1,148 +1,142 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Plex;
 using ErsatzTV.Infrastructure.Plex.Models;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.Plex
+namespace ErsatzTV.Infrastructure.Plex;
+
+public class PlexTvApiClient : IPlexTvApiClient
 {
-    public class PlexTvApiClient : IPlexTvApiClient
+    private const string AppName = "ErsatzTV";
+    private readonly ILogger<PlexTvApiClient> _logger;
+    private readonly IPlexSecretStore _plexSecretStore;
+
+    private readonly IPlexTvApi _plexTvApi;
+
+    public PlexTvApiClient(IPlexTvApi plexTvApi, IPlexSecretStore plexSecretStore, ILogger<PlexTvApiClient> logger)
     {
-        private const string AppName = "ErsatzTV";
-        private readonly ILogger<PlexTvApiClient> _logger;
-        private readonly IPlexSecretStore _plexSecretStore;
+        _plexTvApi = plexTvApi;
+        _plexSecretStore = plexSecretStore;
+        _logger = logger;
+    }
 
-        private readonly IPlexTvApi _plexTvApi;
-
-        public PlexTvApiClient(IPlexTvApi plexTvApi, IPlexSecretStore plexSecretStore, ILogger<PlexTvApiClient> logger)
+    public async Task<Either<BaseError, List<PlexMediaSource>>> GetServers()
+    {
+        try
         {
-            _plexTvApi = plexTvApi;
-            _plexSecretStore = plexSecretStore;
-            _logger = logger;
-        }
-
-        public async Task<Either<BaseError, List<PlexMediaSource>>> GetServers()
-        {
-            try
+            var result = new List<PlexMediaSource>();
+            string clientIdentifier = await _plexSecretStore.GetClientIdentifier();
+            foreach (PlexUserAuthToken token in await _plexSecretStore.GetUserAuthTokens())
             {
-                var result = new List<PlexMediaSource>();
-                string clientIdentifier = await _plexSecretStore.GetClientIdentifier();
-                foreach (PlexUserAuthToken token in await _plexSecretStore.GetUserAuthTokens())
+                List<PlexResource> httpResources = await _plexTvApi.GetResources(
+                    0,
+                    clientIdentifier,
+                    token.AuthToken);
+
+                List<PlexResource> httpsResources = await _plexTvApi.GetResources(
+                    1,
+                    clientIdentifier,
+                    token.AuthToken);
+
+
+                var allResources = httpResources.Filter(resource => resource.HttpsRequired == false)
+                    .Append(httpsResources.Filter(resource => resource.HttpsRequired))
+                    .ToList();
+
+                IEnumerable<PlexResource> ownedResources = allResources
+                    .Filter(r => r.Provides.Split(",").Any(p => p == "server"))
+                    .Filter(r => r.Owned); // TODO: maybe support non-owned servers in the future
+
+
+                foreach (PlexResource resource in ownedResources)
                 {
-                    List<PlexResource> httpResources = await _plexTvApi.GetResources(
-                        0,
-                        clientIdentifier,
-                        token.AuthToken);
+                    var serverAuthToken = new PlexServerAuthToken(
+                        resource.ClientIdentifier,
+                        resource.AccessToken);
 
-                    List<PlexResource> httpsResources = await _plexTvApi.GetResources(
-                        1,
-                        clientIdentifier,
-                        token.AuthToken);
+                    await _plexSecretStore.UpsertServerAuthToken(serverAuthToken);
+                    List<PlexResourceConnection> sortedConnections = resource.HttpsRequired
+                        ? resource.Connections
+                        : resource.Connections.OrderBy(c => c.Local ? 0 : 1).ToList();
 
-
-                    var allResources = httpResources.Filter(resource => resource.HttpsRequired == false)
-                        .Append(httpsResources.Filter(resource => resource.HttpsRequired))
-                        .ToList();
-
-                    IEnumerable<PlexResource> ownedResources = allResources
-                        .Filter(r => r.Provides.Split(",").Any(p => p == "server"))
-                        .Filter(r => r.Owned); // TODO: maybe support non-owned servers in the future
-
-
-                    foreach (PlexResource resource in ownedResources)
+                    var source = new PlexMediaSource
                     {
-                        var serverAuthToken = new PlexServerAuthToken(
-                            resource.ClientIdentifier,
-                            resource.AccessToken);
+                        ServerName = resource.Name,
+                        ProductVersion = resource.ProductVersion,
+                        Platform = resource.Platform,
+                        PlatformVersion = resource.PlatformVersion,
+                        ClientIdentifier = resource.ClientIdentifier,
+                        Connections = sortedConnections
+                            .Map(c => new PlexConnection { Uri = c.Uri }).ToList()
+                    };
 
-                        await _plexSecretStore.UpsertServerAuthToken(serverAuthToken);
-                        List<PlexResourceConnection> sortedConnections = resource.HttpsRequired
-                            ? resource.Connections
-                            : resource.Connections.OrderBy(c => c.Local ? 0 : 1).ToList();
-
-                        var source = new PlexMediaSource
-                        {
-                            ServerName = resource.Name,
-                            ProductVersion = resource.ProductVersion,
-                            Platform = resource.Platform,
-                            PlatformVersion = resource.PlatformVersion,
-                            ClientIdentifier = resource.ClientIdentifier,
-                            Connections = sortedConnections
-                                .Map(c => new PlexConnection { Uri = c.Uri }).ToList()
-                        };
-
-                        result.Add(source);
-                    }
+                    result.Add(source);
                 }
+            }
 
-                return result;
-            }
-            catch (ApiException apiException)
-            {
-                if (apiException.ReasonPhrase == "Unauthorized")
-                {
-                    await _plexSecretStore.DeleteAll();
-                }
-
-                return BaseError.New(apiException.Message);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting plex servers");
-                return BaseError.New(ex.Message);
-            }
+            return result;
         }
-
-        public async Task<Either<BaseError, PlexAuthPin>> StartPinFlow()
+        catch (ApiException apiException)
         {
-            try
+            if (apiException.ReasonPhrase == "Unauthorized")
             {
-                string clientIdentifier = await _plexSecretStore.GetClientIdentifier();
-                PlexPinResponse pinResponse = await _plexTvApi.StartPinFlow(AppName, clientIdentifier);
-                return new PlexAuthPin(pinResponse.Id, pinResponse.Code, clientIdentifier);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error starting plex pin flow");
-                return BaseError.New(ex.Message);
+                await _plexSecretStore.DeleteAll();
             }
+
+            return BaseError.New(apiException.Message);
         }
-
-        public async Task<bool> TryCompletePinFlow(PlexAuthPin authPin)
+        catch (Exception ex)
         {
-            try
-            {
-                PlexTokenResponse response = await _plexTvApi.GetPinStatus(
-                    authPin.Id,
-                    authPin.Code,
-                    authPin.ClientIdentifier);
-
-                if (!string.IsNullOrWhiteSpace(response.AuthToken))
-                {
-                    PlexUserResponse user = await _plexTvApi.GetUser(
-                        AppName,
-                        authPin.ClientIdentifier,
-                        response.AuthToken);
-
-                    var token = new PlexUserAuthToken(user.Email, user.AuthToken);
-                    await _plexSecretStore.UpsertUserAuthToken(token);
-
-                    return true;
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error completing plex pin flow");
-            }
-
-            return false;
+            _logger.LogError(ex, "Error getting plex servers");
+            return BaseError.New(ex.Message);
         }
     }
-}
+
+    public async Task<Either<BaseError, PlexAuthPin>> StartPinFlow()
+    {
+        try
+        {
+            string clientIdentifier = await _plexSecretStore.GetClientIdentifier();
+            PlexPinResponse pinResponse = await _plexTvApi.StartPinFlow(AppName, clientIdentifier);
+            return new PlexAuthPin(pinResponse.Id, pinResponse.Code, clientIdentifier);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error starting plex pin flow");
+            return BaseError.New(ex.Message);
+        }
+    }
+
+    public async Task<bool> TryCompletePinFlow(PlexAuthPin authPin)
+    {
+        try
+        {
+            PlexTokenResponse response = await _plexTvApi.GetPinStatus(
+                authPin.Id,
+                authPin.Code,
+                authPin.ClientIdentifier);
+
+            if (!string.IsNullOrWhiteSpace(response.AuthToken))
+            {
+                PlexUserResponse user = await _plexTvApi.GetUser(
+                    AppName,
+                    authPin.ClientIdentifier,
+                    response.AuthToken);
+
+                var token = new PlexUserAuthToken(user.Email, user.AuthToken);
+                await _plexSecretStore.UpsertUserAuthToken(token);
+
+                return true;
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error completing plex pin flow");
+        }
+
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Runtime/RuntimeInfo.cs b/ErsatzTV.Infrastructure/Runtime/RuntimeInfo.cs
index dd5b7fc2c..f39fbcd0c 100644
--- a/ErsatzTV.Infrastructure/Runtime/RuntimeInfo.cs
+++ b/ErsatzTV.Infrastructure/Runtime/RuntimeInfo.cs
@@ -1,10 +1,9 @@
 using System.Runtime.InteropServices;
 using ErsatzTV.Core.Interfaces.Runtime;
 
-namespace ErsatzTV.Infrastructure.Runtime
+namespace ErsatzTV.Infrastructure.Runtime;
+
+public class RuntimeInfo : IRuntimeInfo
 {
-    public class RuntimeInfo : IRuntimeInfo
-    {
-        public bool IsOSPlatform(OSPlatform osPlatform) => RuntimeInformation.IsOSPlatform(osPlatform);
-    }
-}
+    public bool IsOSPlatform(OSPlatform osPlatform) => RuntimeInformation.IsOSPlatform(osPlatform);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Search/CustomMultiFieldQueryParser.cs b/ErsatzTV.Infrastructure/Search/CustomMultiFieldQueryParser.cs
index 4a122871d..f8d37f5c3 100644
--- a/ErsatzTV.Infrastructure/Search/CustomMultiFieldQueryParser.cs
+++ b/ErsatzTV.Infrastructure/Search/CustomMultiFieldQueryParser.cs
@@ -1,91 +1,89 @@
-using System;
-using System.Collections.Generic;
-using Lucene.Net.Analysis;
+using Lucene.Net.Analysis;
 using Lucene.Net.Index;
 using Lucene.Net.QueryParsers.Classic;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
+using Query = Lucene.Net.Search.Query;
 
-namespace ErsatzTV.Infrastructure.Search
+namespace ErsatzTV.Infrastructure.Search;
+
+public class CustomMultiFieldQueryParser : MultiFieldQueryParser
 {
-    public class CustomMultiFieldQueryParser : MultiFieldQueryParser
+    public CustomMultiFieldQueryParser(
+        LuceneVersion matchVersion,
+        string[] fields,
+        Analyzer analyzer,
+        IDictionary<string, float> boosts) : base(matchVersion, fields, analyzer, boosts)
     {
-        public CustomMultiFieldQueryParser(
-            LuceneVersion matchVersion,
-            string[] fields,
-            Analyzer analyzer,
-            IDictionary<string, float> boosts) : base(matchVersion, fields, analyzer, boosts)
-        {
-        }
-
-        public CustomMultiFieldQueryParser(LuceneVersion matchVersion, string[] fields, Analyzer analyzer) : base(
-            matchVersion,
-            fields,
-            analyzer)
-        {
-        }
-
-        protected override Query GetFieldQuery(string field, string queryText, bool quoted)
-        {
-            if (field == "released_onthisday")
-            {
-                var todayString = DateTime.Today.ToString("*MMdd");
-                return base.GetWildcardQuery("release_date", todayString);
-            }
-            
-            if (field == "minutes" && int.TryParse(queryText, out int val))
-            {
-                var bytesRef = new BytesRef();
-                NumericUtils.Int32ToPrefixCoded(val, 0, bytesRef);
-                return NewTermQuery(new Term("minutes", bytesRef));
-            }
-
-            return base.GetFieldQuery(field, queryText, quoted);
-        }
-
-        protected override Query GetFieldQuery(string field, string queryText, int slop)
-        {
-            if (field == "released_inthelast" && CustomQueryParser.ParseStart(queryText, out DateTime start))
-            {
-                var todayString = DateTime.Today.ToString("yyyyMMdd");
-                var dateString = start.ToString("yyyyMMdd");
-
-                return base.GetRangeQuery("release_date", dateString, todayString, true, true);
-            }
-            
-            if (field == "released_notinthelast" && CustomQueryParser.ParseStart(queryText, out DateTime finish))
-            {
-                var dateString = finish.ToString("yyyyMMdd");
-
-                return base.GetRangeQuery("release_date", "00000000", dateString, false, false);
-            }
-            
-            if (field == "added_inthelast" && CustomQueryParser.ParseStart(queryText, out DateTime addedStart))
-            {
-                var todayString = DateTime.Today.ToString("yyyyMMdd");
-                var dateString = addedStart.ToString("yyyyMMdd");
-
-                return base.GetRangeQuery("added_date", dateString, todayString, true, true);
-            }
-            
-            if (field == "added_notinthelast" && CustomQueryParser.ParseStart(queryText, out DateTime addedFinish))
-            {
-                var dateString = addedFinish.ToString("yyyyMMdd");
-
-                return base.GetRangeQuery("added_date", "00000000", dateString, false, false);
-            }
-            
-            return base.GetFieldQuery(field, queryText, slop);
-        }
-        
-        protected override Query GetRangeQuery(string field, string part1, string part2, bool startInclusive, bool endInclusive)
-        {
-            if (field == "minutes" && int.TryParse(part1, out int min) && int.TryParse(part2, out int max))
-            {
-                return NumericRangeQuery.NewInt32Range(field, min, max, startInclusive, endInclusive);
-            }
-
-            return base.GetRangeQuery(field, part1, part2, startInclusive, endInclusive);
-        }
     }
-}
+
+    public CustomMultiFieldQueryParser(LuceneVersion matchVersion, string[] fields, Analyzer analyzer) : base(
+        matchVersion,
+        fields,
+        analyzer)
+    {
+    }
+
+    protected override Query GetFieldQuery(string field, string queryText, bool quoted)
+    {
+        if (field == "released_onthisday")
+        {
+            var todayString = DateTime.Today.ToString("*MMdd");
+            return base.GetWildcardQuery("release_date", todayString);
+        }
+            
+        if (field == "minutes" && int.TryParse(queryText, out int val))
+        {
+            var bytesRef = new BytesRef();
+            NumericUtils.Int32ToPrefixCoded(val, 0, bytesRef);
+            return NewTermQuery(new Term("minutes", bytesRef));
+        }
+
+        return base.GetFieldQuery(field, queryText, quoted);
+    }
+
+    protected override Query GetFieldQuery(string field, string queryText, int slop)
+    {
+        if (field == "released_inthelast" && CustomQueryParser.ParseStart(queryText, out DateTime start))
+        {
+            var todayString = DateTime.Today.ToString("yyyyMMdd");
+            var dateString = start.ToString("yyyyMMdd");
+
+            return base.GetRangeQuery("release_date", dateString, todayString, true, true);
+        }
+            
+        if (field == "released_notinthelast" && CustomQueryParser.ParseStart(queryText, out DateTime finish))
+        {
+            var dateString = finish.ToString("yyyyMMdd");
+
+            return base.GetRangeQuery("release_date", "00000000", dateString, false, false);
+        }
+            
+        if (field == "added_inthelast" && CustomQueryParser.ParseStart(queryText, out DateTime addedStart))
+        {
+            var todayString = DateTime.Today.ToString("yyyyMMdd");
+            var dateString = addedStart.ToString("yyyyMMdd");
+
+            return base.GetRangeQuery("added_date", dateString, todayString, true, true);
+        }
+            
+        if (field == "added_notinthelast" && CustomQueryParser.ParseStart(queryText, out DateTime addedFinish))
+        {
+            var dateString = addedFinish.ToString("yyyyMMdd");
+
+            return base.GetRangeQuery("added_date", "00000000", dateString, false, false);
+        }
+            
+        return base.GetFieldQuery(field, queryText, slop);
+    }
+        
+    protected override Query GetRangeQuery(string field, string part1, string part2, bool startInclusive, bool endInclusive)
+    {
+        if (field == "minutes" && int.TryParse(part1, out int min) && int.TryParse(part2, out int max))
+        {
+            return NumericRangeQuery.NewInt32Range(field, min, max, startInclusive, endInclusive);
+        }
+
+        return base.GetRangeQuery(field, part1, part2, startInclusive, endInclusive);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Search/CustomQueryParser.cs b/ErsatzTV.Infrastructure/Search/CustomQueryParser.cs
index ebc51a426..a9dd57f50 100644
--- a/ErsatzTV.Infrastructure/Search/CustomQueryParser.cs
+++ b/ErsatzTV.Infrastructure/Search/CustomQueryParser.cs
@@ -1,129 +1,128 @@
-using System;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using Lucene.Net.Analysis;
 using Lucene.Net.Index;
 using Lucene.Net.QueryParsers.Classic;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
+using Query = Lucene.Net.Search.Query;
 
-namespace ErsatzTV.Infrastructure.Search
+namespace ErsatzTV.Infrastructure.Search;
+
+public class CustomQueryParser : QueryParser
 {
-    public class CustomQueryParser : QueryParser
+    public CustomQueryParser(LuceneVersion matchVersion, string f, Analyzer a) : base(matchVersion, f, a)
     {
-        public CustomQueryParser(LuceneVersion matchVersion, string f, Analyzer a) : base(matchVersion, f, a)
-        {
-        }
+    }
 
-        protected internal CustomQueryParser(ICharStream stream) : base(stream)
-        {
-        }
+    protected internal CustomQueryParser(ICharStream stream) : base(stream)
+    {
+    }
 
-        protected CustomQueryParser(QueryParserTokenManager tm) : base(tm)
-        {
-        }
+    protected CustomQueryParser(QueryParserTokenManager tm) : base(tm)
+    {
+    }
         
-        protected override Query GetFieldQuery(string field, string queryText, bool quoted)
+    protected override Query GetFieldQuery(string field, string queryText, bool quoted)
+    {
+        if (field == "released_onthisday")
         {
-            if (field == "released_onthisday")
-            {
-                var todayString = DateTime.Today.ToString("*MMdd");
-                return base.GetWildcardQuery("release_date", todayString);
-            }
+            var todayString = DateTime.Today.ToString("*MMdd");
+            return base.GetWildcardQuery("release_date", todayString);
+        }
             
-            if (field == "minutes" && int.TryParse(queryText, out int val))
-            {
-                var bytesRef = new BytesRef();
-                NumericUtils.Int32ToPrefixCoded(val, 0, bytesRef);
-                return NewTermQuery(new Term("minutes", bytesRef));
-            }
-
-            return base.GetFieldQuery(field, queryText, quoted);
+        if (field == "minutes" && int.TryParse(queryText, out int val))
+        {
+            var bytesRef = new BytesRef();
+            NumericUtils.Int32ToPrefixCoded(val, 0, bytesRef);
+            return NewTermQuery(new Term("minutes", bytesRef));
         }
 
-        protected override Query GetFieldQuery(string field, string queryText, int slop)
+        return base.GetFieldQuery(field, queryText, quoted);
+    }
+
+    protected override Query GetFieldQuery(string field, string queryText, int slop)
+    {
+        if (field == "released_inthelast" && ParseStart(queryText, out DateTime start))
         {
-            if (field == "released_inthelast" && ParseStart(queryText, out DateTime start))
-            {
-                var todayString = DateTime.Today.ToString("yyyyMMdd");
-                var dateString = start.ToString("yyyyMMdd");
+            var todayString = DateTime.Today.ToString("yyyyMMdd");
+            var dateString = start.ToString("yyyyMMdd");
 
-                return base.GetRangeQuery("release_date", dateString, todayString, true, true);
-            }
-            
-            if (field == "released_notinthelast" && ParseStart(queryText, out DateTime finish))
-            {
-                var dateString = finish.ToString("yyyyMMdd");
-
-                return base.GetRangeQuery("release_date", "00000000", dateString, false, false);
-            }
-
-            if (field == "added_inthelast" && ParseStart(queryText, out DateTime addedStart))
-            {
-                var todayString = DateTime.Today.ToString("yyyyMMdd");
-                var dateString = addedStart.ToString("yyyyMMdd");
-
-                return base.GetRangeQuery("added_date", dateString, todayString, true, true);
-            }
-            
-            if (field == "added_notinthelast" && ParseStart(queryText, out DateTime addedFinish))
-            {
-                var dateString = addedFinish.ToString("yyyyMMdd");
-
-                return base.GetRangeQuery("added_date", "00000000", dateString, false, false);
-            }
-
-            return base.GetFieldQuery(field, queryText, slop);
+            return base.GetRangeQuery("release_date", dateString, todayString, true, true);
         }
+            
+        if (field == "released_notinthelast" && ParseStart(queryText, out DateTime finish))
+        {
+            var dateString = finish.ToString("yyyyMMdd");
+
+            return base.GetRangeQuery("release_date", "00000000", dateString, false, false);
+        }
+
+        if (field == "added_inthelast" && ParseStart(queryText, out DateTime addedStart))
+        {
+            var todayString = DateTime.Today.ToString("yyyyMMdd");
+            var dateString = addedStart.ToString("yyyyMMdd");
+
+            return base.GetRangeQuery("added_date", dateString, todayString, true, true);
+        }
+            
+        if (field == "added_notinthelast" && ParseStart(queryText, out DateTime addedFinish))
+        {
+            var dateString = addedFinish.ToString("yyyyMMdd");
+
+            return base.GetRangeQuery("added_date", "00000000", dateString, false, false);
+        }
+
+        return base.GetFieldQuery(field, queryText, slop);
+    }
         
-        protected override Query GetRangeQuery(string field, string part1, string part2, bool startInclusive, bool endInclusive)
+    protected override Query GetRangeQuery(string field, string part1, string part2, bool startInclusive, bool endInclusive)
+    {
+        if (field == "minutes" && int.TryParse(part1, out int min) && int.TryParse(part2, out int max))
         {
-            if (field == "minutes" && int.TryParse(part1, out int min) && int.TryParse(part2, out int max))
-            {
-                return NumericRangeQuery.NewInt32Range(field, 1, min, max, startInclusive, endInclusive);
-            }
-
-            return base.GetRangeQuery(field, part1, part2, startInclusive, endInclusive);
+            return NumericRangeQuery.NewInt32Range(field, 1, min, max, startInclusive, endInclusive);
         }
-        
-        internal static bool ParseStart(string text, out DateTime start)
-        {
-            start = SystemTime.MinValueUtc;
 
-            try
+        return base.GetRangeQuery(field, part1, part2, startInclusive, endInclusive);
+    }
+        
+    internal static bool ParseStart(string text, out DateTime start)
+    {
+        start = SystemTime.MinValueUtc;
+
+        try
+        {
+            if (int.TryParse(text.Split(" ")[0], out int number))
             {
-                if (int.TryParse(text.Split(" ")[0], out int number))
+                if (text.Contains("day"))
                 {
-                    if (text.Contains("day"))
-                    {
-                        start = DateTime.Today.AddDays(number * -1);
-                        return true;
-                    }
+                    start = DateTime.Today.AddDays(number * -1);
+                    return true;
+                }
 
-                    if (text.Contains("week"))
-                    {
-                        start = DateTime.Today.AddDays(number * -7);
-                        return true;
-                    }
+                if (text.Contains("week"))
+                {
+                    start = DateTime.Today.AddDays(number * -7);
+                    return true;
+                }
 
-                    if (text.Contains("month"))
-                    {
-                        start = DateTime.Today.AddMonths(number * -1);
-                        return true;
-                    }
+                if (text.Contains("month"))
+                {
+                    start = DateTime.Today.AddMonths(number * -1);
+                    return true;
+                }
 
-                    if (text.Contains("year"))
-                    {
-                        start = DateTime.Today.AddYears(number * -1);
-                        return true;
-                    }
+                if (text.Contains("year"))
+                {
+                    start = DateTime.Today.AddYears(number * -1);
+                    return true;
                 }
             }
-            catch
-            {
-                // do nothing
-            }
-
-            return false;
         }
+        catch
+        {
+            // do nothing
+        }
+
+        return false;
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Search/SearchIndex.cs b/ErsatzTV.Infrastructure/Search/SearchIndex.cs
index 9ffc9fb60..d73334d5a 100644
--- a/ErsatzTV.Infrastructure/Search/SearchIndex.cs
+++ b/ErsatzTV.Infrastructure/Search/SearchIndex.cs
@@ -1,15 +1,10 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Globalization;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
 using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Core.Search;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.Core;
@@ -25,89 +20,199 @@ using Lucene.Net.Util;
 using Microsoft.Extensions.Logging;
 using Query = Lucene.Net.Search.Query;
 
-namespace ErsatzTV.Infrastructure.Search
+namespace ErsatzTV.Infrastructure.Search;
+
+public sealed class SearchIndex : ISearchIndex
 {
-    public sealed class SearchIndex : ISearchIndex
+    private const LuceneVersion AppLuceneVersion = LuceneVersion.LUCENE_48;
+
+    private const string IdField = "id";
+    private const string TypeField = "type";
+    private const string TitleField = "title";
+    private const string SortTitleField = "sort_title";
+    private const string GenreField = "genre";
+    private const string TagField = "tag";
+    private const string PlotField = "plot";
+    private const string LibraryNameField = "library_name";
+    private const string LibraryIdField = "library_id";
+    private const string TitleAndYearField = "title_and_year";
+    private const string JumpLetterField = "jump_letter";
+    private const string ReleaseDateField = "release_date";
+    private const string AddedDateField = "added_date";
+    private const string StudioField = "studio";
+    private const string LanguageField = "language";
+    private const string StyleField = "style";
+    private const string MoodField = "mood";
+    private const string ActorField = "actor";
+    private const string ContentRatingField = "content_rating";
+    private const string DirectorField = "director";
+    private const string WriterField = "writer";
+    private const string TraktListField = "trakt_list";
+    private const string AlbumField = "album";
+    private const string MinutesField = "minutes";
+    private const string ArtistField = "artist";
+    private const string StateField = "state";
+
+    public const string MovieType = "movie";
+    public const string ShowType = "show";
+    public const string SeasonType = "season";
+    public const string ArtistType = "artist";
+    public const string MusicVideoType = "music_video";
+    public const string EpisodeType = "episode";
+    public const string OtherVideoType = "other_video";
+    public const string SongType = "song";
+    private readonly List<CultureInfo> _cultureInfos;
+
+    private readonly ILogger<SearchIndex> _logger;
+
+    private FSDirectory _directory;
+    private bool _initialized;
+    private IndexWriter _writer;
+
+    public SearchIndex(ILogger<SearchIndex> logger)
     {
-        private const LuceneVersion AppLuceneVersion = LuceneVersion.LUCENE_48;
+        _logger = logger;
+        _cultureInfos = CultureInfo.GetCultures(CultureTypes.NeutralCultures).ToList();
+        _initialized = false;
+    }
 
-        private const string IdField = "id";
-        private const string TypeField = "type";
-        private const string TitleField = "title";
-        private const string SortTitleField = "sort_title";
-        private const string GenreField = "genre";
-        private const string TagField = "tag";
-        private const string PlotField = "plot";
-        private const string LibraryNameField = "library_name";
-        private const string LibraryIdField = "library_id";
-        private const string TitleAndYearField = "title_and_year";
-        private const string JumpLetterField = "jump_letter";
-        private const string ReleaseDateField = "release_date";
-        private const string AddedDateField = "added_date";
-        private const string StudioField = "studio";
-        private const string LanguageField = "language";
-        private const string StyleField = "style";
-        private const string MoodField = "mood";
-        private const string ActorField = "actor";
-        private const string ContentRatingField = "content_rating";
-        private const string DirectorField = "director";
-        private const string WriterField = "writer";
-        private const string TraktListField = "trakt_list";
-        private const string AlbumField = "album";
-        private const string MinutesField = "minutes";
-        private const string ArtistField = "artist";
-        private const string StateField = "state";
+    public int Version => 20;
 
-        public const string MovieType = "movie";
-        public const string ShowType = "show";
-        public const string SeasonType = "season";
-        public const string ArtistType = "artist";
-        public const string MusicVideoType = "music_video";
-        public const string EpisodeType = "episode";
-        public const string OtherVideoType = "other_video";
-        public const string SongType = "song";
-        private readonly List<CultureInfo> _cultureInfos;
-
-        private readonly ILogger<SearchIndex> _logger;
-
-        private FSDirectory _directory;
-        private bool _initialized;
-        private IndexWriter _writer;
-
-        public SearchIndex(ILogger<SearchIndex> logger)
+    public Task<bool> Initialize(ILocalFileSystem localFileSystem)
+    {
+        if (!_initialized)
         {
-            _logger = logger;
-            _cultureInfos = CultureInfo.GetCultures(CultureTypes.NeutralCultures).ToList();
-            _initialized = false;
+            localFileSystem.EnsureFolderExists(FileSystemLayout.SearchIndexFolder);
+
+            _directory = FSDirectory.Open(FileSystemLayout.SearchIndexFolder);
+            var analyzer = new StandardAnalyzer(AppLuceneVersion);
+            var indexConfig = new IndexWriterConfig(AppLuceneVersion, analyzer)
+                { OpenMode = OpenMode.CREATE_OR_APPEND };
+            _writer = new IndexWriter(_directory, indexConfig);
+            _initialized = true;
         }
 
-        public int Version => 20;
+        return Task.FromResult(_initialized);
+    }
 
-        public Task<bool> Initialize(ILocalFileSystem localFileSystem)
+    public Task<Unit> AddItems(ISearchRepository searchRepository, List<MediaItem> items) =>
+        UpdateItems(searchRepository, items);
+
+    public async Task<Unit> UpdateItems(ISearchRepository searchRepository, List<MediaItem> items)
+    {
+        foreach (MediaItem item in items)
         {
-            if (!_initialized)
+            switch (item)
             {
-                localFileSystem.EnsureFolderExists(FileSystemLayout.SearchIndexFolder);
-
-                _directory = FSDirectory.Open(FileSystemLayout.SearchIndexFolder);
-                var analyzer = new StandardAnalyzer(AppLuceneVersion);
-                var indexConfig = new IndexWriterConfig(AppLuceneVersion, analyzer)
-                    { OpenMode = OpenMode.CREATE_OR_APPEND };
-                _writer = new IndexWriter(_directory, indexConfig);
-                _initialized = true;
+                case Movie movie:
+                    await UpdateMovie(searchRepository, movie);
+                    break;
+                case Show show:
+                    await UpdateShow(searchRepository, show);
+                    break;
+                case Season season:
+                    await UpdateSeason(searchRepository, season);
+                    break;
+                case Artist artist:
+                    await UpdateArtist(searchRepository, artist);
+                    break;
+                case MusicVideo musicVideo:
+                    await UpdateMusicVideo(searchRepository, musicVideo);
+                    break;
+                case Episode episode:
+                    await UpdateEpisode(searchRepository, episode);
+                    break;
+                case OtherVideo otherVideo:
+                    await UpdateOtherVideo(searchRepository, otherVideo);
+                    break;
+                case Song song:
+                    await UpdateSong(searchRepository, song);
+                    break;
             }
-
-            return Task.FromResult(_initialized);
         }
 
-        public Task<Unit> AddItems(ISearchRepository searchRepository, List<MediaItem> items) =>
-            UpdateItems(searchRepository, items);
+        return Unit.Default;
+    }
 
-        public async Task<Unit> UpdateItems(ISearchRepository searchRepository, List<MediaItem> items)
+    public Task<Unit> RemoveItems(List<int> ids)
+    {
+        foreach (int id in ids)
         {
-            foreach (MediaItem item in items)
+            _writer.DeleteDocuments(new Term(IdField, id.ToString()));
+        }
+
+        return Task.FromResult(Unit.Default);
+    }
+
+    public Task<SearchResult> Search(string searchQuery, int skip, int limit, string searchField = "")
+    {
+        if (string.IsNullOrWhiteSpace(searchQuery.Replace("*", string.Empty).Replace("?", string.Empty)))
+        {
+            return new SearchResult(new List<SearchItem>(), 0).AsTask();
+        }
+
+        using DirectoryReader reader = _writer.GetReader(true);
+        var searcher = new IndexSearcher(reader);
+        int hitsLimit = limit == 0 ? searcher.IndexReader.MaxDoc : skip + limit;
+        using var analyzer = new StandardAnalyzer(AppLuceneVersion);
+        var customAnalyzers = new Dictionary<string, Analyzer>
+        {
+            { ContentRatingField, new KeywordAnalyzer() },
+            { StateField, new KeywordAnalyzer() }
+        };
+        using var analyzerWrapper = new PerFieldAnalyzerWrapper(analyzer, customAnalyzers);
+        QueryParser parser = !string.IsNullOrWhiteSpace(searchField)
+            ? new CustomQueryParser(AppLuceneVersion, searchField, analyzerWrapper)
+            : new CustomMultiFieldQueryParser(AppLuceneVersion, new[] { TitleField }, analyzerWrapper);
+        parser.AllowLeadingWildcard = true;
+        Query query = ParseQuery(searchQuery, parser);
+        var filter = new DuplicateFilter(TitleAndYearField);
+        var sort = new Sort(new SortField(SortTitleField, SortFieldType.STRING));
+        TopFieldDocs topDocs = searcher.Search(query, filter, hitsLimit, sort, true, true);
+        IEnumerable<ScoreDoc> selectedHits = topDocs.ScoreDocs.Skip(skip);
+
+        if (limit > 0)
+        {
+            selectedHits = selectedHits.Take(limit);
+        }
+
+        var searchResult = new SearchResult(
+            selectedHits.Map(d => ProjectToSearchItem(searcher.Doc(d.Doc))).ToList(),
+            topDocs.TotalHits);
+
+        if (limit > 0)
+        {
+            searchResult.PageMap = GetSearchPageMap(searcher, query, filter, sort, limit);
+        }
+
+        return searchResult.AsTask();
+    }
+
+    public void Commit() => _writer.Commit();
+
+    public void Dispose()
+    {
+        _writer?.Dispose();
+        _directory?.Dispose();
+    }
+
+    public async Task<Unit> Rebuild(ISearchRepository searchRepository, List<int> itemIds)
+    {
+        _writer.DeleteAll();
+
+        await RebuildItems(searchRepository, itemIds);
+
+        _writer.Commit();
+        return Unit.Default;
+    }
+
+    public async Task<Unit> RebuildItems(ISearchRepository searchRepository, List<int> itemIds)
+    {
+        foreach (int id in itemIds)
+        {
+            foreach (MediaItem mediaItem in await searchRepository.GetItemToIndex(id))
             {
-                switch (item)
+                switch (mediaItem)
                 {
                     case Movie movie:
                         await UpdateMovie(searchRepository, movie);
@@ -135,828 +240,717 @@ namespace ErsatzTV.Infrastructure.Search
                         break;
                 }
             }
-
-            return Unit.Default;
         }
 
-        public Task<Unit> RemoveItems(List<int> ids)
+        return Unit.Default;
+    }
+
+    private static Option<SearchPageMap> GetSearchPageMap(
+        IndexSearcher searcher,
+        Query query,
+        DuplicateFilter filter,
+        Sort sort,
+        int limit)
+    {
+        ScoreDoc[] allDocs = searcher.Search(query, filter, int.MaxValue, sort, true, true).ScoreDocs;
+        var letters = new List<char>
         {
-            foreach (int id in ids)
+            '#', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+            'u', 'v', 'w', 'x', 'y', 'z'
+        };
+        var map = letters.ToDictionary(letter => letter, _ => 0);
+
+        var current = 0;
+        var page = 0;
+        while (current < allDocs.Length)
+        {
+            // walk up by page size (limit)
+            page++;
+            current += limit;
+            if (current > allDocs.Length)
             {
-                _writer.DeleteDocuments(new Term(IdField, id.ToString()));
+                current = allDocs.Length;
             }
 
-            return Task.FromResult(Unit.Default);
-        }
-
-        public Task<SearchResult> Search(string searchQuery, int skip, int limit, string searchField = "")
-        {
-            if (string.IsNullOrWhiteSpace(searchQuery.Replace("*", string.Empty).Replace("?", string.Empty)))
+            char jumpLetter = searcher.Doc(allDocs[current - 1].Doc).Get(JumpLetterField).Head();
+            foreach (char letter in letters.Where(l => letters.IndexOf(l) <= letters.IndexOf(jumpLetter)))
             {
-                return new SearchResult(new List<SearchItem>(), 0).AsTask();
-            }
-
-            using DirectoryReader reader = _writer.GetReader(true);
-            var searcher = new IndexSearcher(reader);
-            int hitsLimit = limit == 0 ? searcher.IndexReader.MaxDoc : skip + limit;
-            using var analyzer = new StandardAnalyzer(AppLuceneVersion);
-            var customAnalyzers = new Dictionary<string, Analyzer>
-            {
-                { ContentRatingField, new KeywordAnalyzer() },
-                { StateField, new KeywordAnalyzer() }
-            };
-            using var analyzerWrapper = new PerFieldAnalyzerWrapper(analyzer, customAnalyzers);
-            QueryParser parser = !string.IsNullOrWhiteSpace(searchField)
-                ? new CustomQueryParser(AppLuceneVersion, searchField, analyzerWrapper)
-                : new CustomMultiFieldQueryParser(AppLuceneVersion, new[] { TitleField }, analyzerWrapper);
-            parser.AllowLeadingWildcard = true;
-            Query query = ParseQuery(searchQuery, parser);
-            var filter = new DuplicateFilter(TitleAndYearField);
-            var sort = new Sort(new SortField(SortTitleField, SortFieldType.STRING));
-            TopFieldDocs topDocs = searcher.Search(query, filter, hitsLimit, sort, true, true);
-            IEnumerable<ScoreDoc> selectedHits = topDocs.ScoreDocs.Skip(skip);
-
-            if (limit > 0)
-            {
-                selectedHits = selectedHits.Take(limit);
-            }
-
-            var searchResult = new SearchResult(
-                selectedHits.Map(d => ProjectToSearchItem(searcher.Doc(d.Doc))).ToList(),
-                topDocs.TotalHits);
-
-            if (limit > 0)
-            {
-                searchResult.PageMap = GetSearchPageMap(searcher, query, filter, sort, limit);
-            }
-
-            return searchResult.AsTask();
-        }
-
-        public void Commit() => _writer.Commit();
-
-        public void Dispose()
-        {
-            _writer?.Dispose();
-            _directory?.Dispose();
-        }
-
-        public async Task<Unit> Rebuild(ISearchRepository searchRepository, List<int> itemIds)
-        {
-            _writer.DeleteAll();
-
-            await RebuildItems(searchRepository, itemIds);
-
-            _writer.Commit();
-            return Unit.Default;
-        }
-
-        public async Task<Unit> RebuildItems(ISearchRepository searchRepository, List<int> itemIds)
-        {
-            foreach (int id in itemIds)
-            {
-                foreach (MediaItem mediaItem in await searchRepository.GetItemToIndex(id))
+                if (map[letter] == 0)
                 {
-                    switch (mediaItem)
-                    {
-                        case Movie movie:
-                            await UpdateMovie(searchRepository, movie);
-                            break;
-                        case Show show:
-                            await UpdateShow(searchRepository, show);
-                            break;
-                        case Season season:
-                            await UpdateSeason(searchRepository, season);
-                            break;
-                        case Artist artist:
-                            await UpdateArtist(searchRepository, artist);
-                            break;
-                        case MusicVideo musicVideo:
-                            await UpdateMusicVideo(searchRepository, musicVideo);
-                            break;
-                        case Episode episode:
-                            await UpdateEpisode(searchRepository, episode);
-                            break;
-                        case OtherVideo otherVideo:
-                            await UpdateOtherVideo(searchRepository, otherVideo);
-                            break;
-                        case Song song:
-                            await UpdateSong(searchRepository, song);
-                            break;
-                    }
-                }
-            }
-
-            return Unit.Default;
-        }
-
-        private static Option<SearchPageMap> GetSearchPageMap(
-            IndexSearcher searcher,
-            Query query,
-            DuplicateFilter filter,
-            Sort sort,
-            int limit)
-        {
-            ScoreDoc[] allDocs = searcher.Search(query, filter, int.MaxValue, sort, true, true).ScoreDocs;
-            var letters = new List<char>
-            {
-                '#', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
-                'u', 'v', 'w', 'x', 'y', 'z'
-            };
-            var map = letters.ToDictionary(letter => letter, _ => 0);
-
-            var current = 0;
-            var page = 0;
-            while (current < allDocs.Length)
-            {
-                // walk up by page size (limit)
-                page++;
-                current += limit;
-                if (current > allDocs.Length)
-                {
-                    current = allDocs.Length;
-                }
-
-                char jumpLetter = searcher.Doc(allDocs[current - 1].Doc).Get(JumpLetterField).Head();
-                foreach (char letter in letters.Where(l => letters.IndexOf(l) <= letters.IndexOf(jumpLetter)))
-                {
-                    if (map[letter] == 0)
-                    {
-                        map[letter] = page;
-                    }
-                }
-            }
-
-            int max = map.Values.Max();
-            foreach (char letter in letters.Where(letter => map[letter] == 0))
-            {
-                map[letter] = max;
-            }
-
-            return new SearchPageMap(map);
-        }
-
-        private async Task UpdateMovie(ISearchRepository searchRepository, Movie movie)
-        {
-            Option<MovieMetadata> maybeMetadata = movie.MovieMetadata.HeadOrNone();
-            if (maybeMetadata.IsSome)
-            {
-                MovieMetadata metadata = maybeMetadata.ValueUnsafe();
-
-                try
-                {
-                    var doc = new Document
-                    {
-                        new StringField(IdField, movie.Id.ToString(), Field.Store.YES),
-                        new StringField(TypeField, MovieType, Field.Store.YES),
-                        new TextField(TitleField, metadata.Title, Field.Store.NO),
-                        new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
-                        new TextField(LibraryNameField, movie.LibraryPath.Library.Name, Field.Store.NO),
-                        new StringField(LibraryIdField, movie.LibraryPath.Library.Id.ToString(), Field.Store.NO),
-                        new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
-                        new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
-                        new StringField(StateField, movie.State.ToString(), Field.Store.NO)
-                    };
-
-                    await AddLanguages(searchRepository, doc, movie.MediaVersions);
-                    
-                    foreach (MediaVersion version in movie.MediaVersions.HeadOrNone())
-                    {
-                        doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
-                    }
-
-                    if (!string.IsNullOrWhiteSpace(metadata.ContentRating))
-                    {
-                        foreach (string contentRating in (metadata.ContentRating ?? string.Empty).Split("/")
-                            .Map(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)))
-                        {
-                            doc.Add(new StringField(ContentRatingField, contentRating, Field.Store.NO));
-                        }
-                    }
-
-                    if (metadata.ReleaseDate.HasValue)
-                    {
-                        doc.Add(
-                            new StringField(
-                                ReleaseDateField,
-                                metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
-                                Field.Store.NO));
-                    }
-
-                    doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
-
-                    if (!string.IsNullOrWhiteSpace(metadata.Plot))
-                    {
-                        doc.Add(new TextField(PlotField, metadata.Plot ?? string.Empty, Field.Store.NO));
-                    }
-
-                    foreach (Genre genre in metadata.Genres)
-                    {
-                        doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
-                    }
-
-                    foreach (Tag tag in metadata.Tags)
-                    {
-                        doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
-                    }
-
-                    foreach (Studio studio in metadata.Studios)
-                    {
-                        doc.Add(new TextField(StudioField, studio.Name, Field.Store.NO));
-                    }
-
-                    foreach (Actor actor in metadata.Actors)
-                    {
-                        doc.Add(new TextField(ActorField, actor.Name, Field.Store.NO));
-                    }
-
-                    foreach (Director director in metadata.Directors)
-                    {
-                        doc.Add(new TextField(DirectorField, director.Name, Field.Store.NO));
-                    }
-
-                    foreach (Writer writer in metadata.Writers)
-                    {
-                        doc.Add(new TextField(WriterField, writer.Name, Field.Store.NO));
-                    }
-
-                    foreach (TraktListItem item in movie.TraktListItems)
-                    {
-                        doc.Add(new StringField(TraktListField, item.TraktList.TraktId.ToString(), Field.Store.NO));
-                    }
-
-                    _writer.UpdateDocument(new Term(IdField, movie.Id.ToString()), doc);
-                }
-                catch (Exception ex)
-                {
-                    metadata.Movie = null;
-                    _logger.LogWarning(ex, "Error indexing movie with metadata {@Metadata}", metadata);
+                    map[letter] = page;
                 }
             }
         }
 
-        private async Task AddLanguages(ISearchRepository searchRepository, Document doc, List<MediaVersion> mediaVersions)
+        int max = map.Values.Max();
+        foreach (char letter in letters.Where(letter => map[letter] == 0))
         {
-            Option<MediaVersion> maybeVersion = mediaVersions.HeadOrNone();
-            if (maybeVersion.IsSome)
-            {
-                MediaVersion version = maybeVersion.ValueUnsafe();
-                var mediaCodes = version.Streams
-                    .Filter(ms => ms.MediaStreamKind == MediaStreamKind.Audio)
-                    .Map(ms => ms.Language).Distinct()
-                    .ToList();
-
-                await AddLanguages(searchRepository, doc, mediaCodes);
-            }
+            map[letter] = max;
         }
 
-        private async Task AddLanguages(ISearchRepository searchRepository, Document doc, List<string> mediaCodes)
+        return new SearchPageMap(map);
+    }
+
+    private async Task UpdateMovie(ISearchRepository searchRepository, Movie movie)
+    {
+        Option<MovieMetadata> maybeMetadata = movie.MovieMetadata.HeadOrNone();
+        if (maybeMetadata.IsSome)
         {
-            var englishNames = new System.Collections.Generic.HashSet<string>();
-            foreach (string code in await searchRepository.GetAllLanguageCodes(mediaCodes))
-            {
-                Option<CultureInfo> maybeCultureInfo = _cultureInfos.Find(
-                    ci => string.Equals(ci.ThreeLetterISOLanguageName, code, StringComparison.OrdinalIgnoreCase));
-                foreach (CultureInfo cultureInfo in maybeCultureInfo)
-                {
-                    englishNames.Add(cultureInfo.EnglishName);
-                }
-            }
+            MovieMetadata metadata = maybeMetadata.ValueUnsafe();
 
-            foreach (string englishName in englishNames)
-            {
-                doc.Add(new TextField(LanguageField, englishName, Field.Store.NO));
-            }
-        }
-
-        private async Task UpdateShow(ISearchRepository searchRepository, Show show)
-        {
-            Option<ShowMetadata> maybeMetadata = show.ShowMetadata.HeadOrNone();
-            if (maybeMetadata.IsSome)
-            {
-                ShowMetadata metadata = maybeMetadata.ValueUnsafe();
-
-                try
-                {
-                    var doc = new Document
-                    {
-                        new StringField(IdField, show.Id.ToString(), Field.Store.YES),
-                        new StringField(TypeField, ShowType, Field.Store.YES),
-                        new TextField(TitleField, metadata.Title, Field.Store.NO),
-                        new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
-                        new TextField(LibraryNameField, show.LibraryPath.Library.Name, Field.Store.NO),
-                        new StringField(LibraryIdField, show.LibraryPath.Library.Id.ToString(), Field.Store.NO),
-                        new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
-                        new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES)
-                    };
-
-                    List<string> languages = await searchRepository.GetLanguagesForShow(show);
-                    await AddLanguages(searchRepository, doc, languages);
-
-                    if (!string.IsNullOrWhiteSpace(metadata.ContentRating))
-                    {
-                        foreach (string contentRating in (metadata.ContentRating ?? string.Empty).Split("/")
-                            .Map(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)))
-                        {
-                            doc.Add(new StringField(ContentRatingField, contentRating, Field.Store.NO));
-                        }
-                    }
-
-                    if (metadata.ReleaseDate.HasValue)
-                    {
-                        doc.Add(
-                            new StringField(
-                                ReleaseDateField,
-                                metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
-                                Field.Store.NO));
-                    }
-
-                    doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
-
-                    if (!string.IsNullOrWhiteSpace(metadata.Plot))
-                    {
-                        doc.Add(new TextField(PlotField, metadata.Plot ?? string.Empty, Field.Store.NO));
-                    }
-
-                    foreach (Genre genre in metadata.Genres)
-                    {
-                        doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
-                    }
-
-                    foreach (Tag tag in metadata.Tags)
-                    {
-                        doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
-                    }
-
-                    foreach (Studio studio in metadata.Studios)
-                    {
-                        doc.Add(new TextField(StudioField, studio.Name, Field.Store.NO));
-                    }
-
-                    foreach (Actor actor in metadata.Actors)
-                    {
-                        doc.Add(new TextField(ActorField, actor.Name, Field.Store.NO));
-                    }
-                    
-                    foreach (TraktListItem item in show.TraktListItems)
-                    {
-                        doc.Add(new StringField(TraktListField, item.TraktList.TraktId.ToString(), Field.Store.NO));
-                    }
-
-                    _writer.UpdateDocument(new Term(IdField, show.Id.ToString()), doc);
-                }
-                catch (Exception ex)
-                {
-                    metadata.Show = null;
-                    _logger.LogWarning(ex, "Error indexing show with metadata {@Metadata}", metadata);
-                }
-            }
-        }
-        
-        private async Task UpdateSeason(ISearchRepository searchRepository, Season season)
-        {
-            Option<SeasonMetadata> maybeMetadata = season.SeasonMetadata.HeadOrNone();
-            Option<ShowMetadata> maybeShowMetadata = season.Show.ShowMetadata.HeadOrNone();
-            if (maybeMetadata.IsSome && maybeShowMetadata.IsSome)
-            {
-                SeasonMetadata metadata = maybeMetadata.ValueUnsafe();
-                ShowMetadata showMetadata = maybeShowMetadata.ValueUnsafe();
-
-                try
-                {
-                    var seasonTitle = $"{showMetadata.Title} - S{season.SeasonNumber}";
-                    string sortTitle = $"{showMetadata.SortTitle}_{season.SeasonNumber:0000}"
-                        .ToLowerInvariant();
-                    string titleAndYear = $"{showMetadata.Title}_{showMetadata.Year}_{season.SeasonNumber}"
-                        .ToLowerInvariant();
-
-                    var doc = new Document
-                    {
-                        new StringField(IdField, season.Id.ToString(), Field.Store.YES),
-                        new StringField(TypeField, SeasonType, Field.Store.YES),
-                        new TextField(TitleField, seasonTitle, Field.Store.NO),
-                        new StringField(SortTitleField, sortTitle, Field.Store.NO),
-                        new TextField(LibraryNameField, season.LibraryPath.Library.Name, Field.Store.NO),
-                        new StringField(LibraryIdField, season.LibraryPath.Library.Id.ToString(), Field.Store.NO),
-                        new StringField(TitleAndYearField, titleAndYear, Field.Store.NO),
-                        new StringField(JumpLetterField, GetJumpLetter(showMetadata), Field.Store.YES)
-                    };
-
-                    List<string> languages = await searchRepository.GetLanguagesForSeason(season);
-                    await AddLanguages(searchRepository, doc, languages);
-
-                    if (!string.IsNullOrWhiteSpace(showMetadata.ContentRating))
-                    {
-                        foreach (string contentRating in (showMetadata.ContentRating ?? string.Empty).Split("/")
-                            .Map(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)))
-                        {
-                            doc.Add(new StringField(ContentRatingField, contentRating, Field.Store.NO));
-                        }
-                    }
-
-                    if (metadata.ReleaseDate.HasValue)
-                    {
-                        doc.Add(
-                            new StringField(
-                                ReleaseDateField,
-                                metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
-                                Field.Store.NO));
-                    }
-                    
-                    doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
-
-                    foreach (TraktListItem item in season.TraktListItems)
-                    {
-                        doc.Add(new StringField(TraktListField, item.TraktList.TraktId.ToString(), Field.Store.NO));
-                    }
-
-                    _writer.UpdateDocument(new Term(IdField, season.Id.ToString()), doc);
-                }
-                catch (Exception ex)
-                {
-                    metadata.Season = null;
-                    _logger.LogWarning(ex, "Error indexing show with metadata {@Metadata}", metadata);
-                }
-            }
-        }
-
-        private async Task UpdateArtist(ISearchRepository searchRepository, Artist artist)
-        {
-            Option<ArtistMetadata> maybeMetadata = artist.ArtistMetadata.HeadOrNone();
-            if (maybeMetadata.IsSome)
-            {
-                ArtistMetadata metadata = maybeMetadata.ValueUnsafe();
-
-                try
-                {
-                    var doc = new Document
-                    {
-                        new StringField(IdField, artist.Id.ToString(), Field.Store.YES),
-                        new StringField(TypeField, ArtistType, Field.Store.YES),
-                        new TextField(TitleField, metadata.Title, Field.Store.NO),
-                        new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
-                        new TextField(LibraryNameField, artist.LibraryPath.Library.Name, Field.Store.NO),
-                        new StringField(LibraryIdField, artist.LibraryPath.Library.Id.ToString(), Field.Store.NO),
-                        new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
-                        new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES)
-                    };
-
-                    List<string> languages = await searchRepository.GetLanguagesForArtist(artist);
-                    await AddLanguages(searchRepository, doc, languages);
-                    
-                    doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
-
-                    foreach (Genre genre in metadata.Genres)
-                    {
-                        doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
-                    }
-
-                    foreach (Style style in metadata.Styles)
-                    {
-                        doc.Add(new TextField(StyleField, style.Name, Field.Store.NO));
-                    }
-
-                    foreach (Mood mood in metadata.Moods)
-                    {
-                        doc.Add(new TextField(MoodField, mood.Name, Field.Store.NO));
-                    }
-
-                    _writer.UpdateDocument(new Term(IdField, artist.Id.ToString()), doc);
-                }
-                catch (Exception ex)
-                {
-                    metadata.Artist = null;
-                    _logger.LogWarning(ex, "Error indexing artist with metadata {@Metadata}", metadata);
-                }
-            }
-        }
-
-        private async Task UpdateMusicVideo(ISearchRepository searchRepository, MusicVideo musicVideo)
-        {
-            Option<MusicVideoMetadata> maybeMetadata = musicVideo.MusicVideoMetadata.HeadOrNone();
-            if (maybeMetadata.IsSome)
-            {
-                MusicVideoMetadata metadata = maybeMetadata.ValueUnsafe();
-
-                try
-                {
-                    var doc = new Document
-                    {
-                        new StringField(IdField, musicVideo.Id.ToString(), Field.Store.YES),
-                        new StringField(TypeField, MusicVideoType, Field.Store.YES),
-                        new TextField(TitleField, metadata.Title, Field.Store.NO),
-                        new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
-                        new TextField(LibraryNameField, musicVideo.LibraryPath.Library.Name, Field.Store.NO),
-                        new StringField(LibraryIdField, musicVideo.LibraryPath.Library.Id.ToString(), Field.Store.NO),
-                        new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
-                        new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
-                        new StringField(StateField, musicVideo.State.ToString(), Field.Store.NO)
-                    };
-
-                    await AddLanguages(searchRepository, doc, musicVideo.MediaVersions);
-                    
-                    foreach (MediaVersion version in musicVideo.MediaVersions.HeadOrNone())
-                    {
-                        doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
-                    }
-
-                    if (metadata.ReleaseDate.HasValue)
-                    {
-                        doc.Add(
-                            new StringField(
-                                ReleaseDateField,
-                                metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
-                                Field.Store.NO));
-                    }
-                    
-                    doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
-
-                    if (!string.IsNullOrWhiteSpace(metadata.Album))
-                    {
-                        doc.Add(new TextField(AlbumField, metadata.Album, Field.Store.NO));
-                    }
-
-                    if (!string.IsNullOrWhiteSpace(metadata.Plot))
-                    {
-                        doc.Add(new TextField(PlotField, metadata.Plot ?? string.Empty, Field.Store.NO));
-                    }
-
-                    foreach (Genre genre in metadata.Genres)
-                    {
-                        doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
-                    }
-
-                    foreach (Tag tag in metadata.Tags)
-                    {
-                        doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
-                    }
-
-                    foreach (Studio studio in metadata.Studios)
-                    {
-                        doc.Add(new TextField(StudioField, studio.Name, Field.Store.NO));
-                    }
-                    
-                    if (musicVideo.Artist != null)
-                    {
-                        foreach (ArtistMetadata artistMetadata in musicVideo.Artist.ArtistMetadata)
-                        {
-                            doc.Add(new TextField(ArtistField, artistMetadata.Title, Field.Store.NO));
-                        }
-                    }
-
-                    _writer.UpdateDocument(new Term(IdField, musicVideo.Id.ToString()), doc);
-                }
-                catch (Exception ex)
-                {
-                    metadata.MusicVideo = null;
-                    _logger.LogWarning(ex, "Error indexing music video with metadata {@Metadata}", metadata);
-                }
-            }
-        }
-
-        private async Task UpdateEpisode(ISearchRepository searchRepository, Episode episode)
-        {
-            foreach (EpisodeMetadata metadata in episode.EpisodeMetadata)
-            {
-                try
-                {
-                    if (string.IsNullOrWhiteSpace(metadata.Title))
-                    {
-                        _logger.LogWarning(
-                            "Unable to index episode without title {Show} s{Season}e{Episode}",
-                            metadata.Episode.Season?.Show?.ShowMetadata.Head().Title,
-                            metadata.Episode.Season?.SeasonNumber,
-                            metadata.EpisodeNumber);
-
-                        continue;
-                    }
-
-                    var doc = new Document
-                    {
-                        new StringField(IdField, episode.Id.ToString(), Field.Store.YES),
-                        new StringField(TypeField, EpisodeType, Field.Store.YES),
-                        new TextField(TitleField, metadata.Title, Field.Store.NO),
-                        new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
-                        new TextField(LibraryNameField, episode.LibraryPath.Library.Name, Field.Store.NO),
-                        new StringField(LibraryIdField, episode.LibraryPath.Library.Id.ToString(), Field.Store.NO),
-                        new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
-                        new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
-                        new StringField(StateField, episode.State.ToString(), Field.Store.NO)
-                    };
-
-                    await AddLanguages(searchRepository, doc, episode.MediaVersions);
-                    
-                    foreach (MediaVersion version in episode.MediaVersions.HeadOrNone())
-                    {
-                        doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
-                    }
-
-                    if (metadata.ReleaseDate.HasValue)
-                    {
-                        doc.Add(
-                            new StringField(
-                                ReleaseDateField,
-                                metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
-                                Field.Store.NO));
-                    }
-                    
-                    doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
-
-                    if (!string.IsNullOrWhiteSpace(metadata.Plot))
-                    {
-                        doc.Add(new TextField(PlotField, metadata.Plot ?? string.Empty, Field.Store.NO));
-                    }
-
-                    foreach (Genre genre in metadata.Genres)
-                    {
-                        doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
-                    }
-
-                    foreach (Tag tag in metadata.Tags)
-                    {
-                        doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
-                    }
-
-                    foreach (Studio studio in metadata.Studios)
-                    {
-                        doc.Add(new TextField(StudioField, studio.Name, Field.Store.NO));
-                    }
-
-                    foreach (Actor actor in metadata.Actors)
-                    {
-                        doc.Add(new TextField(ActorField, actor.Name, Field.Store.NO));
-                    }
-
-                    foreach (Director director in metadata.Directors)
-                    {
-                        doc.Add(new TextField(DirectorField, director.Name, Field.Store.NO));
-                    }
-
-                    foreach (Writer writer in metadata.Writers)
-                    {
-                        doc.Add(new TextField(WriterField, writer.Name, Field.Store.NO));
-                    }
-
-                    foreach (TraktListItem item in episode.TraktListItems)
-                    {
-                        doc.Add(new StringField(TraktListField, item.TraktList.TraktId.ToString(), Field.Store.NO));
-                    }
-
-                    _writer.UpdateDocument(new Term(IdField, episode.Id.ToString()), doc);
-                }
-                catch (Exception ex)
-                {
-                    metadata.Episode = null;
-                    _logger.LogWarning(ex, "Error indexing episode with metadata {@Metadata}", metadata);
-                }
-            }
-        }
-        
-        private async Task UpdateOtherVideo(ISearchRepository searchRepository, OtherVideo otherVideo)
-        {
-            Option<OtherVideoMetadata> maybeMetadata = otherVideo.OtherVideoMetadata.HeadOrNone();
-            if (maybeMetadata.IsSome)
-            {
-                OtherVideoMetadata metadata = maybeMetadata.ValueUnsafe();
-
-                try
-                {
-                    var doc = new Document
-                    {
-                        new StringField(IdField, otherVideo.Id.ToString(), Field.Store.YES),
-                        new StringField(TypeField, OtherVideoType, Field.Store.YES),
-                        new TextField(TitleField, metadata.Title, Field.Store.NO),
-                        new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
-                        new TextField(LibraryNameField, otherVideo.LibraryPath.Library.Name, Field.Store.NO),
-                        new StringField(LibraryIdField, otherVideo.LibraryPath.Library.Id.ToString(), Field.Store.NO),
-                        new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
-                        new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
-                        new StringField(StateField, otherVideo.State.ToString(), Field.Store.NO)
-                    };
-
-                    await AddLanguages(searchRepository, doc, otherVideo.MediaVersions);
-                    
-                    foreach (MediaVersion version in otherVideo.MediaVersions.HeadOrNone())
-                    {
-                        doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
-                    }
-                    
-                    doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
-
-                    foreach (Tag tag in metadata.Tags)
-                    {
-                        doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
-                    }
-
-                    _writer.UpdateDocument(new Term(IdField, otherVideo.Id.ToString()), doc);
-                }
-                catch (Exception ex)
-                {
-                    metadata.OtherVideo = null;
-                    _logger.LogWarning(ex, "Error indexing other video with metadata {@Metadata}", metadata);
-                }
-            }
-        }
-        
-        private async Task UpdateSong(ISearchRepository searchRepository, Song song)
-        {
-            Option<SongMetadata> maybeMetadata = song.SongMetadata.HeadOrNone();
-            if (maybeMetadata.IsSome)
-            {
-                SongMetadata metadata = maybeMetadata.ValueUnsafe();
-
-                try
-                {
-                    var doc = new Document
-                    {
-                        new StringField(IdField, song.Id.ToString(), Field.Store.YES),
-                        new StringField(TypeField, SongType, Field.Store.YES),
-                        new TextField(TitleField, metadata.Title, Field.Store.NO),
-                        new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
-                        new TextField(LibraryNameField, song.LibraryPath.Library.Name, Field.Store.NO),
-                        new StringField(LibraryIdField, song.LibraryPath.Library.Id.ToString(), Field.Store.NO),
-                        new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
-                        new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
-                        new StringField(StateField, song.State.ToString(), Field.Store.NO)
-                    };
-
-                    await AddLanguages(searchRepository, doc, song.MediaVersions);
-                    
-                    foreach (MediaVersion version in song.MediaVersions.HeadOrNone())
-                    {
-                        doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
-                    }
-                    
-                    doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
-
-                    if (!string.IsNullOrWhiteSpace(metadata.Album))
-                    {
-                        doc.Add(new TextField(AlbumField, metadata.Album, Field.Store.NO));
-                    }
-                    
-                    if (!string.IsNullOrWhiteSpace(metadata.Artist))
-                    {
-                        doc.Add(new TextField(ArtistField, metadata.Artist, Field.Store.NO));
-                    }
-
-                    foreach (Tag tag in metadata.Tags)
-                    {
-                        doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
-                    }
-
-                    foreach (Genre genre in metadata.Genres)
-                    {
-                        doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
-                    }
-
-                    _writer.UpdateDocument(new Term(IdField, song.Id.ToString()), doc);
-                }
-                catch (Exception ex)
-                {
-                    metadata.Song = null;
-                    _logger.LogWarning(ex, "Error indexing song with metadata {@Metadata}", metadata);
-                }
-            }
-        }
-
-        private SearchItem ProjectToSearchItem(Document doc) => new(
-            doc.Get(TypeField),
-            Convert.ToInt32(doc.Get(IdField)));
-
-        private Query ParseQuery(string searchQuery, QueryParser parser)
-        {
-            Query query;
             try
             {
-                query = parser.Parse(searchQuery.Trim());
-            }
-            catch (ParseException)
-            {
-                query = parser.Parse(QueryParserBase.Escape(searchQuery.Trim()));
-            }
+                var doc = new Document
+                {
+                    new StringField(IdField, movie.Id.ToString(), Field.Store.YES),
+                    new StringField(TypeField, MovieType, Field.Store.YES),
+                    new TextField(TitleField, metadata.Title, Field.Store.NO),
+                    new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
+                    new TextField(LibraryNameField, movie.LibraryPath.Library.Name, Field.Store.NO),
+                    new StringField(LibraryIdField, movie.LibraryPath.Library.Id.ToString(), Field.Store.NO),
+                    new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
+                    new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
+                    new StringField(StateField, movie.State.ToString(), Field.Store.NO)
+                };
 
-            return query;
-        }
+                await AddLanguages(searchRepository, doc, movie.MediaVersions);
+                    
+                foreach (MediaVersion version in movie.MediaVersions.HeadOrNone())
+                {
+                    doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
+                }
 
-        private static string GetTitleAndYear(Metadata metadata) =>
-            metadata switch
+                if (!string.IsNullOrWhiteSpace(metadata.ContentRating))
+                {
+                    foreach (string contentRating in (metadata.ContentRating ?? string.Empty).Split("/")
+                             .Map(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)))
+                    {
+                        doc.Add(new StringField(ContentRatingField, contentRating, Field.Store.NO));
+                    }
+                }
+
+                if (metadata.ReleaseDate.HasValue)
+                {
+                    doc.Add(
+                        new StringField(
+                            ReleaseDateField,
+                            metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
+                            Field.Store.NO));
+                }
+
+                doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
+
+                if (!string.IsNullOrWhiteSpace(metadata.Plot))
+                {
+                    doc.Add(new TextField(PlotField, metadata.Plot ?? string.Empty, Field.Store.NO));
+                }
+
+                foreach (Genre genre in metadata.Genres)
+                {
+                    doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
+                }
+
+                foreach (Tag tag in metadata.Tags)
+                {
+                    doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
+                }
+
+                foreach (Studio studio in metadata.Studios)
+                {
+                    doc.Add(new TextField(StudioField, studio.Name, Field.Store.NO));
+                }
+
+                foreach (Actor actor in metadata.Actors)
+                {
+                    doc.Add(new TextField(ActorField, actor.Name, Field.Store.NO));
+                }
+
+                foreach (Director director in metadata.Directors)
+                {
+                    doc.Add(new TextField(DirectorField, director.Name, Field.Store.NO));
+                }
+
+                foreach (Writer writer in metadata.Writers)
+                {
+                    doc.Add(new TextField(WriterField, writer.Name, Field.Store.NO));
+                }
+
+                foreach (TraktListItem item in movie.TraktListItems)
+                {
+                    doc.Add(new StringField(TraktListField, item.TraktList.TraktId.ToString(), Field.Store.NO));
+                }
+
+                _writer.UpdateDocument(new Term(IdField, movie.Id.ToString()), doc);
+            }
+            catch (Exception ex)
             {
-                EpisodeMetadata em =>
-                    $"{em.Title}_{em.Year}_{em.Episode.Season.SeasonNumber}_{em.EpisodeNumber}"
-                        .ToLowerInvariant(),
-                OtherVideoMetadata ovm => $"{ovm.OriginalTitle}".ToLowerInvariant(),
-                SongMetadata sm => $"{sm.OriginalTitle}".ToLowerInvariant(),
-                _ => $"{metadata.Title}_{metadata.Year}".ToLowerInvariant()
-            };
-        
-        private static string GetJumpLetter(Metadata metadata)
-        {
-            char c = metadata.SortTitle.ToLowerInvariant().Head();
-            return c switch
-            {
-                (>= 'a' and <= 'z') => c.ToString(),
-                _ => "#"
-            };
+                metadata.Movie = null;
+                _logger.LogWarning(ex, "Error indexing movie with metadata {@Metadata}", metadata);
+            }
         }
     }
-}
+
+    private async Task AddLanguages(ISearchRepository searchRepository, Document doc, List<MediaVersion> mediaVersions)
+    {
+        Option<MediaVersion> maybeVersion = mediaVersions.HeadOrNone();
+        if (maybeVersion.IsSome)
+        {
+            MediaVersion version = maybeVersion.ValueUnsafe();
+            var mediaCodes = version.Streams
+                .Filter(ms => ms.MediaStreamKind == MediaStreamKind.Audio)
+                .Map(ms => ms.Language).Distinct()
+                .ToList();
+
+            await AddLanguages(searchRepository, doc, mediaCodes);
+        }
+    }
+
+    private async Task AddLanguages(ISearchRepository searchRepository, Document doc, List<string> mediaCodes)
+    {
+        var englishNames = new System.Collections.Generic.HashSet<string>();
+        foreach (string code in await searchRepository.GetAllLanguageCodes(mediaCodes))
+        {
+            Option<CultureInfo> maybeCultureInfo = _cultureInfos.Find(
+                ci => string.Equals(ci.ThreeLetterISOLanguageName, code, StringComparison.OrdinalIgnoreCase));
+            foreach (CultureInfo cultureInfo in maybeCultureInfo)
+            {
+                englishNames.Add(cultureInfo.EnglishName);
+            }
+        }
+
+        foreach (string englishName in englishNames)
+        {
+            doc.Add(new TextField(LanguageField, englishName, Field.Store.NO));
+        }
+    }
+
+    private async Task UpdateShow(ISearchRepository searchRepository, Show show)
+    {
+        Option<ShowMetadata> maybeMetadata = show.ShowMetadata.HeadOrNone();
+        if (maybeMetadata.IsSome)
+        {
+            ShowMetadata metadata = maybeMetadata.ValueUnsafe();
+
+            try
+            {
+                var doc = new Document
+                {
+                    new StringField(IdField, show.Id.ToString(), Field.Store.YES),
+                    new StringField(TypeField, ShowType, Field.Store.YES),
+                    new TextField(TitleField, metadata.Title, Field.Store.NO),
+                    new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
+                    new TextField(LibraryNameField, show.LibraryPath.Library.Name, Field.Store.NO),
+                    new StringField(LibraryIdField, show.LibraryPath.Library.Id.ToString(), Field.Store.NO),
+                    new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
+                    new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES)
+                };
+
+                List<string> languages = await searchRepository.GetLanguagesForShow(show);
+                await AddLanguages(searchRepository, doc, languages);
+
+                if (!string.IsNullOrWhiteSpace(metadata.ContentRating))
+                {
+                    foreach (string contentRating in (metadata.ContentRating ?? string.Empty).Split("/")
+                             .Map(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)))
+                    {
+                        doc.Add(new StringField(ContentRatingField, contentRating, Field.Store.NO));
+                    }
+                }
+
+                if (metadata.ReleaseDate.HasValue)
+                {
+                    doc.Add(
+                        new StringField(
+                            ReleaseDateField,
+                            metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
+                            Field.Store.NO));
+                }
+
+                doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
+
+                if (!string.IsNullOrWhiteSpace(metadata.Plot))
+                {
+                    doc.Add(new TextField(PlotField, metadata.Plot ?? string.Empty, Field.Store.NO));
+                }
+
+                foreach (Genre genre in metadata.Genres)
+                {
+                    doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
+                }
+
+                foreach (Tag tag in metadata.Tags)
+                {
+                    doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
+                }
+
+                foreach (Studio studio in metadata.Studios)
+                {
+                    doc.Add(new TextField(StudioField, studio.Name, Field.Store.NO));
+                }
+
+                foreach (Actor actor in metadata.Actors)
+                {
+                    doc.Add(new TextField(ActorField, actor.Name, Field.Store.NO));
+                }
+                    
+                foreach (TraktListItem item in show.TraktListItems)
+                {
+                    doc.Add(new StringField(TraktListField, item.TraktList.TraktId.ToString(), Field.Store.NO));
+                }
+
+                _writer.UpdateDocument(new Term(IdField, show.Id.ToString()), doc);
+            }
+            catch (Exception ex)
+            {
+                metadata.Show = null;
+                _logger.LogWarning(ex, "Error indexing show with metadata {@Metadata}", metadata);
+            }
+        }
+    }
+        
+    private async Task UpdateSeason(ISearchRepository searchRepository, Season season)
+    {
+        Option<SeasonMetadata> maybeMetadata = season.SeasonMetadata.HeadOrNone();
+        Option<ShowMetadata> maybeShowMetadata = season.Show.ShowMetadata.HeadOrNone();
+        if (maybeMetadata.IsSome && maybeShowMetadata.IsSome)
+        {
+            SeasonMetadata metadata = maybeMetadata.ValueUnsafe();
+            ShowMetadata showMetadata = maybeShowMetadata.ValueUnsafe();
+
+            try
+            {
+                var seasonTitle = $"{showMetadata.Title} - S{season.SeasonNumber}";
+                string sortTitle = $"{showMetadata.SortTitle}_{season.SeasonNumber:0000}"
+                    .ToLowerInvariant();
+                string titleAndYear = $"{showMetadata.Title}_{showMetadata.Year}_{season.SeasonNumber}"
+                    .ToLowerInvariant();
+
+                var doc = new Document
+                {
+                    new StringField(IdField, season.Id.ToString(), Field.Store.YES),
+                    new StringField(TypeField, SeasonType, Field.Store.YES),
+                    new TextField(TitleField, seasonTitle, Field.Store.NO),
+                    new StringField(SortTitleField, sortTitle, Field.Store.NO),
+                    new TextField(LibraryNameField, season.LibraryPath.Library.Name, Field.Store.NO),
+                    new StringField(LibraryIdField, season.LibraryPath.Library.Id.ToString(), Field.Store.NO),
+                    new StringField(TitleAndYearField, titleAndYear, Field.Store.NO),
+                    new StringField(JumpLetterField, GetJumpLetter(showMetadata), Field.Store.YES)
+                };
+
+                List<string> languages = await searchRepository.GetLanguagesForSeason(season);
+                await AddLanguages(searchRepository, doc, languages);
+
+                if (!string.IsNullOrWhiteSpace(showMetadata.ContentRating))
+                {
+                    foreach (string contentRating in (showMetadata.ContentRating ?? string.Empty).Split("/")
+                             .Map(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)))
+                    {
+                        doc.Add(new StringField(ContentRatingField, contentRating, Field.Store.NO));
+                    }
+                }
+
+                if (metadata.ReleaseDate.HasValue)
+                {
+                    doc.Add(
+                        new StringField(
+                            ReleaseDateField,
+                            metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
+                            Field.Store.NO));
+                }
+                    
+                doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
+
+                foreach (TraktListItem item in season.TraktListItems)
+                {
+                    doc.Add(new StringField(TraktListField, item.TraktList.TraktId.ToString(), Field.Store.NO));
+                }
+
+                _writer.UpdateDocument(new Term(IdField, season.Id.ToString()), doc);
+            }
+            catch (Exception ex)
+            {
+                metadata.Season = null;
+                _logger.LogWarning(ex, "Error indexing show with metadata {@Metadata}", metadata);
+            }
+        }
+    }
+
+    private async Task UpdateArtist(ISearchRepository searchRepository, Artist artist)
+    {
+        Option<ArtistMetadata> maybeMetadata = artist.ArtistMetadata.HeadOrNone();
+        if (maybeMetadata.IsSome)
+        {
+            ArtistMetadata metadata = maybeMetadata.ValueUnsafe();
+
+            try
+            {
+                var doc = new Document
+                {
+                    new StringField(IdField, artist.Id.ToString(), Field.Store.YES),
+                    new StringField(TypeField, ArtistType, Field.Store.YES),
+                    new TextField(TitleField, metadata.Title, Field.Store.NO),
+                    new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
+                    new TextField(LibraryNameField, artist.LibraryPath.Library.Name, Field.Store.NO),
+                    new StringField(LibraryIdField, artist.LibraryPath.Library.Id.ToString(), Field.Store.NO),
+                    new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
+                    new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES)
+                };
+
+                List<string> languages = await searchRepository.GetLanguagesForArtist(artist);
+                await AddLanguages(searchRepository, doc, languages);
+                    
+                doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
+
+                foreach (Genre genre in metadata.Genres)
+                {
+                    doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
+                }
+
+                foreach (Style style in metadata.Styles)
+                {
+                    doc.Add(new TextField(StyleField, style.Name, Field.Store.NO));
+                }
+
+                foreach (Mood mood in metadata.Moods)
+                {
+                    doc.Add(new TextField(MoodField, mood.Name, Field.Store.NO));
+                }
+
+                _writer.UpdateDocument(new Term(IdField, artist.Id.ToString()), doc);
+            }
+            catch (Exception ex)
+            {
+                metadata.Artist = null;
+                _logger.LogWarning(ex, "Error indexing artist with metadata {@Metadata}", metadata);
+            }
+        }
+    }
+
+    private async Task UpdateMusicVideo(ISearchRepository searchRepository, MusicVideo musicVideo)
+    {
+        Option<MusicVideoMetadata> maybeMetadata = musicVideo.MusicVideoMetadata.HeadOrNone();
+        if (maybeMetadata.IsSome)
+        {
+            MusicVideoMetadata metadata = maybeMetadata.ValueUnsafe();
+
+            try
+            {
+                var doc = new Document
+                {
+                    new StringField(IdField, musicVideo.Id.ToString(), Field.Store.YES),
+                    new StringField(TypeField, MusicVideoType, Field.Store.YES),
+                    new TextField(TitleField, metadata.Title, Field.Store.NO),
+                    new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
+                    new TextField(LibraryNameField, musicVideo.LibraryPath.Library.Name, Field.Store.NO),
+                    new StringField(LibraryIdField, musicVideo.LibraryPath.Library.Id.ToString(), Field.Store.NO),
+                    new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
+                    new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
+                    new StringField(StateField, musicVideo.State.ToString(), Field.Store.NO)
+                };
+
+                await AddLanguages(searchRepository, doc, musicVideo.MediaVersions);
+                    
+                foreach (MediaVersion version in musicVideo.MediaVersions.HeadOrNone())
+                {
+                    doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
+                }
+
+                if (metadata.ReleaseDate.HasValue)
+                {
+                    doc.Add(
+                        new StringField(
+                            ReleaseDateField,
+                            metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
+                            Field.Store.NO));
+                }
+                    
+                doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
+
+                if (!string.IsNullOrWhiteSpace(metadata.Album))
+                {
+                    doc.Add(new TextField(AlbumField, metadata.Album, Field.Store.NO));
+                }
+
+                if (!string.IsNullOrWhiteSpace(metadata.Plot))
+                {
+                    doc.Add(new TextField(PlotField, metadata.Plot ?? string.Empty, Field.Store.NO));
+                }
+
+                foreach (Genre genre in metadata.Genres)
+                {
+                    doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
+                }
+
+                foreach (Tag tag in metadata.Tags)
+                {
+                    doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
+                }
+
+                foreach (Studio studio in metadata.Studios)
+                {
+                    doc.Add(new TextField(StudioField, studio.Name, Field.Store.NO));
+                }
+                    
+                if (musicVideo.Artist != null)
+                {
+                    foreach (ArtistMetadata artistMetadata in musicVideo.Artist.ArtistMetadata)
+                    {
+                        doc.Add(new TextField(ArtistField, artistMetadata.Title, Field.Store.NO));
+                    }
+                }
+
+                _writer.UpdateDocument(new Term(IdField, musicVideo.Id.ToString()), doc);
+            }
+            catch (Exception ex)
+            {
+                metadata.MusicVideo = null;
+                _logger.LogWarning(ex, "Error indexing music video with metadata {@Metadata}", metadata);
+            }
+        }
+    }
+
+    private async Task UpdateEpisode(ISearchRepository searchRepository, Episode episode)
+    {
+        foreach (EpisodeMetadata metadata in episode.EpisodeMetadata)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(metadata.Title))
+                {
+                    _logger.LogWarning(
+                        "Unable to index episode without title {Show} s{Season}e{Episode}",
+                        metadata.Episode.Season?.Show?.ShowMetadata.Head().Title,
+                        metadata.Episode.Season?.SeasonNumber,
+                        metadata.EpisodeNumber);
+
+                    continue;
+                }
+
+                var doc = new Document
+                {
+                    new StringField(IdField, episode.Id.ToString(), Field.Store.YES),
+                    new StringField(TypeField, EpisodeType, Field.Store.YES),
+                    new TextField(TitleField, metadata.Title, Field.Store.NO),
+                    new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
+                    new TextField(LibraryNameField, episode.LibraryPath.Library.Name, Field.Store.NO),
+                    new StringField(LibraryIdField, episode.LibraryPath.Library.Id.ToString(), Field.Store.NO),
+                    new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
+                    new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
+                    new StringField(StateField, episode.State.ToString(), Field.Store.NO)
+                };
+
+                await AddLanguages(searchRepository, doc, episode.MediaVersions);
+                    
+                foreach (MediaVersion version in episode.MediaVersions.HeadOrNone())
+                {
+                    doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
+                }
+
+                if (metadata.ReleaseDate.HasValue)
+                {
+                    doc.Add(
+                        new StringField(
+                            ReleaseDateField,
+                            metadata.ReleaseDate.Value.ToString("yyyyMMdd"),
+                            Field.Store.NO));
+                }
+                    
+                doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
+
+                if (!string.IsNullOrWhiteSpace(metadata.Plot))
+                {
+                    doc.Add(new TextField(PlotField, metadata.Plot ?? string.Empty, Field.Store.NO));
+                }
+
+                foreach (Genre genre in metadata.Genres)
+                {
+                    doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
+                }
+
+                foreach (Tag tag in metadata.Tags)
+                {
+                    doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
+                }
+
+                foreach (Studio studio in metadata.Studios)
+                {
+                    doc.Add(new TextField(StudioField, studio.Name, Field.Store.NO));
+                }
+
+                foreach (Actor actor in metadata.Actors)
+                {
+                    doc.Add(new TextField(ActorField, actor.Name, Field.Store.NO));
+                }
+
+                foreach (Director director in metadata.Directors)
+                {
+                    doc.Add(new TextField(DirectorField, director.Name, Field.Store.NO));
+                }
+
+                foreach (Writer writer in metadata.Writers)
+                {
+                    doc.Add(new TextField(WriterField, writer.Name, Field.Store.NO));
+                }
+
+                foreach (TraktListItem item in episode.TraktListItems)
+                {
+                    doc.Add(new StringField(TraktListField, item.TraktList.TraktId.ToString(), Field.Store.NO));
+                }
+
+                _writer.UpdateDocument(new Term(IdField, episode.Id.ToString()), doc);
+            }
+            catch (Exception ex)
+            {
+                metadata.Episode = null;
+                _logger.LogWarning(ex, "Error indexing episode with metadata {@Metadata}", metadata);
+            }
+        }
+    }
+        
+    private async Task UpdateOtherVideo(ISearchRepository searchRepository, OtherVideo otherVideo)
+    {
+        Option<OtherVideoMetadata> maybeMetadata = otherVideo.OtherVideoMetadata.HeadOrNone();
+        if (maybeMetadata.IsSome)
+        {
+            OtherVideoMetadata metadata = maybeMetadata.ValueUnsafe();
+
+            try
+            {
+                var doc = new Document
+                {
+                    new StringField(IdField, otherVideo.Id.ToString(), Field.Store.YES),
+                    new StringField(TypeField, OtherVideoType, Field.Store.YES),
+                    new TextField(TitleField, metadata.Title, Field.Store.NO),
+                    new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
+                    new TextField(LibraryNameField, otherVideo.LibraryPath.Library.Name, Field.Store.NO),
+                    new StringField(LibraryIdField, otherVideo.LibraryPath.Library.Id.ToString(), Field.Store.NO),
+                    new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
+                    new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
+                    new StringField(StateField, otherVideo.State.ToString(), Field.Store.NO)
+                };
+
+                await AddLanguages(searchRepository, doc, otherVideo.MediaVersions);
+                    
+                foreach (MediaVersion version in otherVideo.MediaVersions.HeadOrNone())
+                {
+                    doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
+                }
+                    
+                doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
+
+                foreach (Tag tag in metadata.Tags)
+                {
+                    doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
+                }
+
+                _writer.UpdateDocument(new Term(IdField, otherVideo.Id.ToString()), doc);
+            }
+            catch (Exception ex)
+            {
+                metadata.OtherVideo = null;
+                _logger.LogWarning(ex, "Error indexing other video with metadata {@Metadata}", metadata);
+            }
+        }
+    }
+        
+    private async Task UpdateSong(ISearchRepository searchRepository, Song song)
+    {
+        Option<SongMetadata> maybeMetadata = song.SongMetadata.HeadOrNone();
+        if (maybeMetadata.IsSome)
+        {
+            SongMetadata metadata = maybeMetadata.ValueUnsafe();
+
+            try
+            {
+                var doc = new Document
+                {
+                    new StringField(IdField, song.Id.ToString(), Field.Store.YES),
+                    new StringField(TypeField, SongType, Field.Store.YES),
+                    new TextField(TitleField, metadata.Title, Field.Store.NO),
+                    new StringField(SortTitleField, metadata.SortTitle.ToLowerInvariant(), Field.Store.NO),
+                    new TextField(LibraryNameField, song.LibraryPath.Library.Name, Field.Store.NO),
+                    new StringField(LibraryIdField, song.LibraryPath.Library.Id.ToString(), Field.Store.NO),
+                    new StringField(TitleAndYearField, GetTitleAndYear(metadata), Field.Store.NO),
+                    new StringField(JumpLetterField, GetJumpLetter(metadata), Field.Store.YES),
+                    new StringField(StateField, song.State.ToString(), Field.Store.NO)
+                };
+
+                await AddLanguages(searchRepository, doc, song.MediaVersions);
+                    
+                foreach (MediaVersion version in song.MediaVersions.HeadOrNone())
+                {
+                    doc.Add(new Int32Field(MinutesField, (int)Math.Ceiling(version.Duration.TotalMinutes), Field.Store.NO));
+                }
+                    
+                doc.Add(new StringField(AddedDateField, metadata.DateAdded.ToString("yyyyMMdd"), Field.Store.NO));
+
+                if (!string.IsNullOrWhiteSpace(metadata.Album))
+                {
+                    doc.Add(new TextField(AlbumField, metadata.Album, Field.Store.NO));
+                }
+                    
+                if (!string.IsNullOrWhiteSpace(metadata.Artist))
+                {
+                    doc.Add(new TextField(ArtistField, metadata.Artist, Field.Store.NO));
+                }
+
+                foreach (Tag tag in metadata.Tags)
+                {
+                    doc.Add(new TextField(TagField, tag.Name, Field.Store.NO));
+                }
+
+                foreach (Genre genre in metadata.Genres)
+                {
+                    doc.Add(new TextField(GenreField, genre.Name, Field.Store.NO));
+                }
+
+                _writer.UpdateDocument(new Term(IdField, song.Id.ToString()), doc);
+            }
+            catch (Exception ex)
+            {
+                metadata.Song = null;
+                _logger.LogWarning(ex, "Error indexing song with metadata {@Metadata}", metadata);
+            }
+        }
+    }
+
+    private SearchItem ProjectToSearchItem(Document doc) => new(
+        doc.Get(TypeField),
+        Convert.ToInt32(doc.Get(IdField)));
+
+    private Query ParseQuery(string searchQuery, QueryParser parser)
+    {
+        Query query;
+        try
+        {
+            query = parser.Parse(searchQuery.Trim());
+        }
+        catch (ParseException)
+        {
+            query = parser.Parse(QueryParserBase.Escape(searchQuery.Trim()));
+        }
+
+        return query;
+    }
+
+    private static string GetTitleAndYear(Metadata metadata) =>
+        metadata switch
+        {
+            EpisodeMetadata em =>
+                $"{em.Title}_{em.Year}_{em.Episode.Season.SeasonNumber}_{em.EpisodeNumber}"
+                    .ToLowerInvariant(),
+            OtherVideoMetadata ovm => $"{ovm.OriginalTitle}".ToLowerInvariant(),
+            SongMetadata sm => $"{sm.OriginalTitle}".ToLowerInvariant(),
+            _ => $"{metadata.Title}_{metadata.Year}".ToLowerInvariant()
+        };
+        
+    private static string GetJumpLetter(Metadata metadata)
+    {
+        char c = metadata.SortTitle.ToLowerInvariant().Head();
+        return c switch
+        {
+            (>= 'a' and <= 'z') => c.ToString(),
+            _ => "#"
+        };
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/ITraktApi.cs b/ErsatzTV.Infrastructure/Trakt/ITraktApi.cs
index 18a15b62f..7aaf3eb91 100644
--- a/ErsatzTV.Infrastructure/Trakt/ITraktApi.cs
+++ b/ErsatzTV.Infrastructure/Trakt/ITraktApi.cs
@@ -1,25 +1,22 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Trakt.Models;
+using ErsatzTV.Infrastructure.Trakt.Models;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.Trakt
+namespace ErsatzTV.Infrastructure.Trakt;
+
+[Headers("Accept: application/json", "trakt-api-version: 2")]
+public interface ITraktApi
 {
-    [Headers("Accept: application/json", "trakt-api-version: 2")]
-    public interface ITraktApi
-    {
-        [Get("/users/{user}/lists/{list}")]
-        Task<TraktListResponse> GetUserList(
-            [Header("trakt-api-key")]
-            string clientId,
-            string user,
-            string list);
+    [Get("/users/{user}/lists/{list}")]
+    Task<TraktListResponse> GetUserList(
+        [Header("trakt-api-key")]
+        string clientId,
+        string user,
+        string list);
         
-        [Get("/users/{user}/lists/{list}/items")]
-        Task<List<TraktListItemResponse>> GetUserListItems(
-            [Header("trakt-api-key")]
-            string clientId,
-            string user,
-            string list);
-    }
-}
+    [Get("/users/{user}/lists/{list}/items")]
+    Task<List<TraktListItemResponse>> GetUserListItems(
+        [Header("trakt-api-key")]
+        string clientId,
+        string user,
+        string list);
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktListIds.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktListIds.cs
index b35d51165..f798e01c3 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktListIds.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktListIds.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktListIds
 {
-    public class TraktListIds
-    {
-        public int Trakt { get; set; }
-        public string Slug { get; set; }
-    }
-}
+    public int Trakt { get; set; }
+    public string Slug { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemEpisode.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemEpisode.cs
index 4e4b2d7a3..1e2488435 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemEpisode.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemEpisode.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktListItemEpisode
 {
-    public class TraktListItemEpisode
-    {
-        public int Season { get; set; }
-        public int Number { get; set; }
-        public string Title { get; set; }
-        public TraktListItemIds Ids { get; set; }
-    }
-}
+    public int Season { get; set; }
+    public int Number { get; set; }
+    public string Title { get; set; }
+    public TraktListItemIds Ids { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemIds.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemIds.cs
index 7079fd1d5..8165c9a99 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemIds.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemIds.cs
@@ -1,10 +1,9 @@
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktListItemIds
 {
-    public class TraktListItemIds
-    {
-        public int Trakt { get; set; }
-        public int? Tvdb { get; set; }
-        public string Imdb { get; set; }
-        public int? Tmdb { get; set; }
-    }
-}
+    public int Trakt { get; set; }
+    public int? Tvdb { get; set; }
+    public string Imdb { get; set; }
+    public int? Tmdb { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemMovie.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemMovie.cs
index f58ad9933..f8cbf93c6 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemMovie.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemMovie.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktListItemMovie
 {
-    public class TraktListItemMovie
-    {
-        public string Title { get; set; }
-        public int? Year { get; set; }
-        public TraktListItemIds Ids { get; set; }
-    }
-}
+    public string Title { get; set; }
+    public int? Year { get; set; }
+    public TraktListItemIds Ids { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemResponse.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemResponse.cs
index a6e011ecf..919de2d3e 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemResponse.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemResponse.cs
@@ -1,13 +1,12 @@
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktListItemResponse
 {
-    public class TraktListItemResponse
-    {
-        public int Rank { get; set; }
-        public int Id { get; set; }
-        public string Type { get; set; }
-        public TraktListItemMovie Movie { get; set; }
-        public TraktListItemShow Show { get; set; }
-        public TraktListItemSeason Season { get; set; }
-        public TraktListItemEpisode Episode { get; set; }
-    }
-}
+    public int Rank { get; set; }
+    public int Id { get; set; }
+    public string Type { get; set; }
+    public TraktListItemMovie Movie { get; set; }
+    public TraktListItemShow Show { get; set; }
+    public TraktListItemSeason Season { get; set; }
+    public TraktListItemEpisode Episode { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemSeason.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemSeason.cs
index 7e6787704..cd5d40d7b 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemSeason.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemSeason.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktListItemSeason
 {
-    public class TraktListItemSeason
-    {
-        public int Number { get; set; }
-        public TraktListItemIds Ids { get; set; }
-    }
-}
+    public int Number { get; set; }
+    public TraktListItemIds Ids { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemShow.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemShow.cs
index f6e372827..c4b6e525e 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemShow.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktListItemShow.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktListItemShow
 {
-    public class TraktListItemShow
-    {
-        public string Title { get; set; }
-        public int? Year { get; set; }
-        public TraktListItemIds Ids { get; set; }
-    }
-}
+    public string Title { get; set; }
+    public int? Year { get; set; }
+    public TraktListItemIds Ids { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktListResponse.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktListResponse.cs
index 4d373a1f1..1d353a4c3 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktListResponse.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktListResponse.cs
@@ -1,14 +1,13 @@
 using Newtonsoft.Json;
 
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktListResponse
 {
-    public class TraktListResponse
-    {
-        public string Name { get; set; }
-        public string Description { get; set; }
-        [JsonProperty("item_count")]
-        public int ItemCount { get; set; }
-        public TraktListIds Ids { get; set; }
-        public TraktUser User { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public string Description { get; set; }
+    [JsonProperty("item_count")]
+    public int ItemCount { get; set; }
+    public TraktListIds Ids { get; set; }
+    public TraktUser User { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/Models/TraktUser.cs b/ErsatzTV.Infrastructure/Trakt/Models/TraktUser.cs
index c6b4b0ea7..169d9981e 100644
--- a/ErsatzTV.Infrastructure/Trakt/Models/TraktUser.cs
+++ b/ErsatzTV.Infrastructure/Trakt/Models/TraktUser.cs
@@ -1,7 +1,6 @@
-namespace ErsatzTV.Infrastructure.Trakt.Models
+namespace ErsatzTV.Infrastructure.Trakt.Models;
+
+public class TraktUser
 {
-    public class TraktUser
-    {
-        public string Username { get; set; }
-    }
-}
+    public string Username { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/SnakeCasePropertyNamesContractResolver.cs b/ErsatzTV.Infrastructure/Trakt/SnakeCasePropertyNamesContractResolver.cs
index bc7056f81..3d7bb7af8 100644
--- a/ErsatzTV.Infrastructure/Trakt/SnakeCasePropertyNamesContractResolver.cs
+++ b/ErsatzTV.Infrastructure/Trakt/SnakeCasePropertyNamesContractResolver.cs
@@ -1,47 +1,44 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
+using System.Globalization;
 using System.Text;
 using Newtonsoft.Json.Serialization;
 
-namespace ErsatzTV.Infrastructure.Trakt
+namespace ErsatzTV.Infrastructure.Trakt;
+
+public class DeliminatorSeparatedPropertyNamesContractResolver : DefaultContractResolver
 {
-    public class DeliminatorSeparatedPropertyNamesContractResolver : DefaultContractResolver
+    readonly string separator;
+
+    protected DeliminatorSeparatedPropertyNamesContractResolver(char separator)
     {
-        readonly string separator;
+        this.separator = separator.ToString(CultureInfo.InvariantCulture);
+    }
 
-        protected DeliminatorSeparatedPropertyNamesContractResolver(char separator)
+    protected override string ResolvePropertyName(string propertyName)
+    {
+        var parts = new List<string>();
+        var currentWord = new StringBuilder();
+
+        foreach (var c in propertyName.ToCharArray())
         {
-            this.separator = separator.ToString(CultureInfo.InvariantCulture);
-        }
-
-        protected override string ResolvePropertyName(string propertyName)
-        {
-            var parts = new List<string>();
-            var currentWord = new StringBuilder();
-
-            foreach (var c in propertyName.ToCharArray())
-            {
-                if (Char.IsUpper(c) && currentWord.Length > 0)
-                {
-                    parts.Add(currentWord.ToString());
-                    currentWord.Clear();
-                }
-
-                currentWord.Append(char.ToLower(c));
-            }
-
-            if (currentWord.Length > 0)
+            if (Char.IsUpper(c) && currentWord.Length > 0)
             {
                 parts.Add(currentWord.ToString());
+                currentWord.Clear();
             }
 
-            return String.Join(separator, parts.ToArray());
+            currentWord.Append(char.ToLower(c));
         }
-    }
 
-    public class SnakeCasePropertyNamesContractResolver : DeliminatorSeparatedPropertyNamesContractResolver
-    {
-        public SnakeCasePropertyNamesContractResolver() : base('_') { }
+        if (currentWord.Length > 0)
+        {
+            parts.Add(currentWord.ToString());
+        }
+
+        return String.Join(separator, parts.ToArray());
     }
 }
+
+public class SnakeCasePropertyNamesContractResolver : DeliminatorSeparatedPropertyNamesContractResolver
+{
+    public SnakeCasePropertyNamesContractResolver() : base('_') { }
+}
\ No newline at end of file
diff --git a/ErsatzTV.Infrastructure/Trakt/TraktApiClient.cs b/ErsatzTV.Infrastructure/Trakt/TraktApiClient.cs
index d59a56623..aae3489d8 100644
--- a/ErsatzTV.Infrastructure/Trakt/TraktApiClient.cs
+++ b/ErsatzTV.Infrastructure/Trakt/TraktApiClient.cs
@@ -1,168 +1,163 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Trakt;
 using ErsatzTV.Core.Trakt;
 using ErsatzTV.Infrastructure.Trakt.Models;
-using LanguageExt;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 using Refit;
 
-namespace ErsatzTV.Infrastructure.Trakt
+namespace ErsatzTV.Infrastructure.Trakt;
+
+public class TraktApiClient : ITraktApiClient
 {
-    public class TraktApiClient : ITraktApiClient
+    private readonly ITraktApi _traktApi;
+    private readonly IOptions<TraktConfiguration> _traktConfiguration;
+    private readonly ILogger<TraktApiClient> _logger;
+
+    public TraktApiClient(
+        ITraktApi traktApi,
+        IOptions<TraktConfiguration> traktConfiguration,
+        ILogger<TraktApiClient> logger)
     {
-        private readonly ITraktApi _traktApi;
-        private readonly IOptions<TraktConfiguration> _traktConfiguration;
-        private readonly ILogger<TraktApiClient> _logger;
+        _traktApi = traktApi;
+        _traktConfiguration = traktConfiguration;
+        _logger = logger;
+    }
 
-        public TraktApiClient(
-            ITraktApi traktApi,
-            IOptions<TraktConfiguration> traktConfiguration,
-            ILogger<TraktApiClient> logger)
+    public async Task<Either<BaseError, TraktList>> GetUserList(string user, string list)
+    {
+        try
         {
-            _traktApi = traktApi;
-            _traktConfiguration = traktConfiguration;
-            _logger = logger;
-        }
+            TraktListResponse response = await JsonService().GetUserList(
+                _traktConfiguration.Value.ClientId,
+                user,
+                list);
 
-        public async Task<Either<BaseError, TraktList>> GetUserList(string user, string list)
+            return new TraktList
+            {
+                TraktId = response.Ids.Trakt,
+                User = response.User.Username,
+                List = response.Ids.Slug,
+                Name = response.Name,
+                Description = response.Description,
+                ItemCount = response.ItemCount,
+                Items = new List<TraktListItem>()
+            };
+        }
+        catch (Exception ex)
         {
-            try
-            {
-                TraktListResponse response = await JsonService().GetUserList(
-                    _traktConfiguration.Value.ClientId,
-                    user,
-                    list);
-
-                return new TraktList
-                {
-                    TraktId = response.Ids.Trakt,
-                    User = response.User.Username,
-                    List = response.Ids.Slug,
-                    Name = response.Name,
-                    Description = response.Description,
-                    ItemCount = response.ItemCount,
-                    Items = new List<TraktListItem>()
-                };
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting trakt list");
-                return BaseError.New(ex.Message);
-            }
+            _logger.LogError(ex, "Error getting trakt list");
+            return BaseError.New(ex.Message);
         }
+    }
         
-        private static ITraktApi JsonService()
-        {
-            return RestService.For<ITraktApi>(
-                "https://api.trakt.tv",
-                new RefitSettings
-                {
-                    ContentSerializer = new NewtonsoftJsonContentSerializer(
-                        new JsonSerializerSettings {
-                            ContractResolver = new SnakeCasePropertyNamesContractResolver()
-                        })
-                });
-        }
-
-        public async Task<Either<BaseError, List<TraktListItemWithGuids>>> GetUserListItems(string user, string list)
-        {
-            try
+    private static ITraktApi JsonService()
+    {
+        return RestService.For<ITraktApi>(
+            "https://api.trakt.tv",
+            new RefitSettings
             {
-                var result = new List<TraktListItemWithGuids>();
+                ContentSerializer = new NewtonsoftJsonContentSerializer(
+                    new JsonSerializerSettings {
+                        ContractResolver = new SnakeCasePropertyNamesContractResolver()
+                    })
+            });
+    }
+
+    public async Task<Either<BaseError, List<TraktListItemWithGuids>>> GetUserListItems(string user, string list)
+    {
+        try
+        {
+            var result = new List<TraktListItemWithGuids>();
                 
-                List<TraktListItemResponse> apiItems = await _traktApi.GetUserListItems(
-                    _traktConfiguration.Value.ClientId,
-                    user,
-                    list);
+            List<TraktListItemResponse> apiItems = await _traktApi.GetUserListItems(
+                _traktConfiguration.Value.ClientId,
+                user,
+                list);
 
-                foreach (TraktListItemResponse apiItem in apiItems)
+            foreach (TraktListItemResponse apiItem in apiItems)
+            {
+                TraktListItemWithGuids item = apiItem.Type.ToLowerInvariant() switch
                 {
-                    TraktListItemWithGuids item = apiItem.Type.ToLowerInvariant() switch
-                    {
-                        "movie" => new TraktListItemWithGuids(
-                            apiItem.Id,
-                            apiItem.Rank,
-                            $"{apiItem.Movie.Title} ({apiItem.Movie.Year})",
-                            apiItem.Movie.Title,
-                            apiItem.Movie.Year,
-                            0,
-                            0,
-                            TraktListItemKind.Movie,
-                            GuidsFromIds(apiItem.Movie.Ids)),
-                        "show" => new TraktListItemWithGuids(
-                            apiItem.Id,
-                            apiItem.Rank,
-                            $"{apiItem.Show.Title} ({apiItem.Show.Year})",
-                            apiItem.Show.Title,
-                            apiItem.Show.Year,
-                            0,
-                            0,
-                            TraktListItemKind.Show,
-                            GuidsFromIds(apiItem.Show.Ids)),
-                        "season" => new TraktListItemWithGuids(
-                            apiItem.Id,
-                            apiItem.Rank,
-                            $"{apiItem.Show.Title} ({apiItem.Show.Year}) S{apiItem.Season.Number:00}",
-                            apiItem.Show.Title,
-                            apiItem.Show.Year,
-                            apiItem.Season.Number,
-                            0,
-                            TraktListItemKind.Season,
-                            GuidsFromIds(apiItem.Season.Ids)),
-                        "episode" => new TraktListItemWithGuids(
-                            apiItem.Id,
-                            apiItem.Rank,
-                            $"{apiItem.Show.Title} ({apiItem.Show.Year}) S{apiItem.Episode.Season:00}E{apiItem.Episode.Number:00}",
-                            apiItem.Show.Title,
-                            apiItem.Show.Year,
-                            apiItem.Episode.Season,
-                            apiItem.Episode.Number,
-                            TraktListItemKind.Episode,
-                            GuidsFromIds(apiItem.Episode.Ids)),
-                        _ => null
-                    };
+                    "movie" => new TraktListItemWithGuids(
+                        apiItem.Id,
+                        apiItem.Rank,
+                        $"{apiItem.Movie.Title} ({apiItem.Movie.Year})",
+                        apiItem.Movie.Title,
+                        apiItem.Movie.Year,
+                        0,
+                        0,
+                        TraktListItemKind.Movie,
+                        GuidsFromIds(apiItem.Movie.Ids)),
+                    "show" => new TraktListItemWithGuids(
+                        apiItem.Id,
+                        apiItem.Rank,
+                        $"{apiItem.Show.Title} ({apiItem.Show.Year})",
+                        apiItem.Show.Title,
+                        apiItem.Show.Year,
+                        0,
+                        0,
+                        TraktListItemKind.Show,
+                        GuidsFromIds(apiItem.Show.Ids)),
+                    "season" => new TraktListItemWithGuids(
+                        apiItem.Id,
+                        apiItem.Rank,
+                        $"{apiItem.Show.Title} ({apiItem.Show.Year}) S{apiItem.Season.Number:00}",
+                        apiItem.Show.Title,
+                        apiItem.Show.Year,
+                        apiItem.Season.Number,
+                        0,
+                        TraktListItemKind.Season,
+                        GuidsFromIds(apiItem.Season.Ids)),
+                    "episode" => new TraktListItemWithGuids(
+                        apiItem.Id,
+                        apiItem.Rank,
+                        $"{apiItem.Show.Title} ({apiItem.Show.Year}) S{apiItem.Episode.Season:00}E{apiItem.Episode.Number:00}",
+                        apiItem.Show.Title,
+                        apiItem.Show.Year,
+                        apiItem.Episode.Season,
+                        apiItem.Episode.Number,
+                        TraktListItemKind.Episode,
+                        GuidsFromIds(apiItem.Episode.Ids)),
+                    _ => null
+                };
 
-                    if (item != null)
-                    {
-                        result.Add(item);
-                    }
+                if (item != null)
+                {
+                    result.Add(item);
                 }
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error getting trakt list items");
-                return BaseError.New(ex.Message);
-            }
-        }
-
-        private static List<string> GuidsFromIds(TraktListItemIds ids)
-        {
-            var result = new List<string>();
-
-            if (!string.IsNullOrWhiteSpace(ids.Imdb))
-            {
-                result.Add($"imdb://{ids.Imdb}");
-            }
-
-            if (ids.Tmdb.HasValue)
-            {
-                result.Add($"tmdb://{ids.Tmdb.Value}");
-            }
-
-            if (ids.Tvdb.HasValue)
-            {
-                result.Add($"tvdb://{ids.Tvdb.Value}");
             }
 
             return result;
         }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting trakt list items");
+            return BaseError.New(ex.Message);
+        }
     }
-}
+
+    private static List<string> GuidsFromIds(TraktListItemIds ids)
+    {
+        var result = new List<string>();
+
+        if (!string.IsNullOrWhiteSpace(ids.Imdb))
+        {
+            result.Add($"imdb://{ids.Imdb}");
+        }
+
+        if (ids.Tmdb.HasValue)
+        {
+            result.Add($"tmdb://{ids.Tmdb.Value}");
+        }
+
+        if (ids.Tvdb.HasValue)
+        {
+            result.Add($"tvdb://{ids.Tvdb.Value}");
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/App.razor b/ErsatzTV/App.razor
index 552da3a94..03dcec2f6 100644
--- a/ErsatzTV/App.razor
+++ b/ErsatzTV/App.razor
@@ -1,10 +1,11 @@
-<Router AppAssembly="@typeof(Program).Assembly" PreferExactMatches="@true">
+<Router AppAssembly="@typeof(Program).Assembly">
     <Found Context="routeData">
         <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)"/>
     </Found>
     <NotFound>
+        <PageTitle>Not found</PageTitle>
         <LayoutView Layout="@typeof(MainLayout)">
-            <p>Sorry, there's nothing at this address.</p>
+            <p role="alert">Sorry, there's nothing at this address.</p>
         </LayoutView>
     </NotFound>
 </Router>
\ No newline at end of file
diff --git a/ErsatzTV/Controllers/ArtworkController.cs b/ErsatzTV/Controllers/ArtworkController.cs
index 4499fb4c7..9bd0862b0 100644
--- a/ErsatzTV/Controllers/ArtworkController.cs
+++ b/ErsatzTV/Controllers/ArtworkController.cs
@@ -1,215 +1,204 @@
-using System;
-using System.IO;
-using System.Net.Http;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Emby;
-using ErsatzTV.Application.Emby.Queries;
+using ErsatzTV.Application.Emby;
 using ErsatzTV.Application.Images;
-using ErsatzTV.Application.Images.Queries;
 using ErsatzTV.Application.Jellyfin;
-using ErsatzTV.Application.Jellyfin.Queries;
 using ErsatzTV.Application.Plex;
-using ErsatzTV.Application.Plex.Queries;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Jellyfin;
 using Flurl;
-using LanguageExt;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
 
-namespace ErsatzTV.Controllers
+namespace ErsatzTV.Controllers;
+
+[ResponseCache(Duration = 3600)]
+[ApiController]
+[ApiExplorerSettings(IgnoreApi = true)]
+public class ArtworkController : ControllerBase
 {
-    [ResponseCache(Duration = 3600)]
-    [ApiController]
-    [ApiExplorerSettings(IgnoreApi = true)]
-    public class ArtworkController : ControllerBase
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly IMediator _mediator;
+
+    public ArtworkController(IMediator mediator, IHttpClientFactory httpClientFactory)
     {
-        private readonly IHttpClientFactory _httpClientFactory;
-        private readonly IMediator _mediator;
-
-        public ArtworkController(IMediator mediator, IHttpClientFactory httpClientFactory)
-        {
-            _mediator = mediator;
-            _httpClientFactory = httpClientFactory;
-        }
-
-        [HttpHead("/iptv/artwork/posters/{fileName}")]
-        [HttpGet("/iptv/artwork/posters/{fileName}")]
-        [HttpHead("/iptv/artwork/posters/{fileName}.jpg")]
-        [HttpGet("/iptv/artwork/posters/{fileName}.jpg")]
-        [HttpGet("/artwork/posters/{fileName}")]
-        public async Task<IActionResult> GetPoster(string fileName, CancellationToken cancellationToken)
-        {
-            Either<BaseError, CachedImagePathViewModel> cachedImagePath =
-                await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.Poster, 440), cancellationToken);
-            return cachedImagePath.Match<IActionResult>(
-                Left: _ => new NotFoundResult(),
-                Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
-        }
-
-        [HttpGet("/artwork/watermarks/{fileName}")]
-        public async Task<IActionResult> GetWatermark(string fileName, CancellationToken cancellationToken)
-        {
-            Either<BaseError, CachedImagePathViewModel> cachedImagePath =
-                await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.Watermark), cancellationToken);
-            return cachedImagePath.Match<IActionResult>(
-                Left: _ => new NotFoundResult(),
-                Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
-        }
-
-        [HttpGet("/artwork/fanart/{fileName}")]
-        public async Task<IActionResult> GetFanArt(string fileName, CancellationToken cancellationToken)
-        {
-            Either<BaseError, CachedImagePathViewModel> cachedImagePath =
-                await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.FanArt), cancellationToken);
-            return cachedImagePath.Match<IActionResult>(
-                Left: _ => new NotFoundResult(),
-                Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
-        }
-
-
-        [HttpHead("/iptv/artwork/posters/jellyfin/{*path}")]
-        [HttpGet("/iptv/artwork/posters/jellyfin/{*path}")]
-        [HttpGet("/artwork/posters/jellyfin/{*path}")]
-        [HttpHead("/iptv/artwork/thumbnails/jellyfin/{*path}")]
-        [HttpGet("/iptv/artwork/thumbnails/jellyfin/{*path}")]
-        [HttpGet("/artwork/thumbnails/jellyfin/{*path}")]
-        [HttpGet("/artwork/fanart/jellyfin/{*path}")]
-        public Task<IActionResult> GetJellyfin(string path, CancellationToken cancellationToken)
-        {
-            if (Request.QueryString.HasValue)
-            {
-                path += Request.QueryString.Value;
-            }
-
-            return GetJellyfinArtwork(path, cancellationToken);
-        }
-
-        [HttpHead("/iptv/artwork/posters/emby/{*path}")]
-        [HttpGet("/iptv/artwork/posters/emby/{*path}")]
-        [HttpGet("/artwork/posters/emby/{*path}")]
-        [HttpHead("/iptv/artwork/thumbnails/emby/{*path}")]
-        [HttpGet("/iptv/artwork/thumbnails/emby/{*path}")]
-        [HttpGet("/artwork/thumbnails/emby/{*path}")]
-        [HttpGet("/artwork/fanart/emby/{*path}")]
-        public Task<IActionResult> GetEmby(string path, CancellationToken cancellationToken)
-        {
-            if (Request.QueryString.HasValue)
-            {
-                path += Request.QueryString.Value;
-            }
-
-            return GetEmbyArtwork(path, cancellationToken);
-        }
-
-        [HttpHead("/iptv/artwork/posters/plex/{plexMediaSourceId}/{*path}")]
-        [HttpGet("/iptv/artwork/posters/plex/{plexMediaSourceId}/{*path}")]
-        [HttpGet("/artwork/posters/plex/{plexMediaSourceId}/{*path}")]
-        public Task<IActionResult> GetPlexPoster(int plexMediaSourceId, string path, CancellationToken cancellationToken) =>
-            GetPlexArtwork(
-                plexMediaSourceId,
-                $"photo/:/transcode?url=/{path}&height=440&width=304&minSize=1&upscale=0",
-                cancellationToken);
-
-        [HttpGet("/artwork/fanart/plex/{plexMediaSourceId}/{*path}")]
-        public Task<IActionResult> GetPlexFanArt(int plexMediaSourceId, string path, CancellationToken cancellationToken) =>
-            GetPlexArtwork(plexMediaSourceId, $"/{path}", cancellationToken);
-
-        [HttpGet("/artwork/thumbnails/plex/{plexMediaSourceId}/{*path}")]
-        public Task<IActionResult> GetPlexThumbnail(int plexMediaSourceId, string path, CancellationToken cancellationToken) =>
-            GetPlexArtwork(
-                plexMediaSourceId,
-                $"photo/:/transcode?url=/{path}&height=220&width=392&minSize=1&upscale=0",
-                cancellationToken);
-
-        [HttpHead("/iptv/artwork/thumbnails/{fileName}")]
-        [HttpGet("/iptv/artwork/thumbnails/{fileName}")]
-        [HttpHead("/iptv/artwork/thumbnails/{fileName}.jpg")]
-        [HttpGet("/iptv/artwork/thumbnails/{fileName}.jpg")]
-        [HttpGet("/artwork/thumbnails/{fileName}")]
-        public async Task<IActionResult> GetThumbnail(string fileName, CancellationToken cancellationToken)
-        {
-            Either<BaseError, CachedImagePathViewModel> cachedImagePath =
-                await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.Thumbnail, 220), cancellationToken);
-            return cachedImagePath.Match<IActionResult>(
-                Left: _ => new NotFoundResult(),
-                Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
-        }
-
-        private async Task<IActionResult> GetPlexArtwork(int plexMediaSourceId, string transcodePath, CancellationToken cancellationToken)
-        {
-            Either<BaseError, PlexConnectionParametersViewModel> connectionParameters =
-                await _mediator.Send(new GetPlexConnectionParameters(plexMediaSourceId), cancellationToken);
-
-            return await connectionParameters.Match<Task<IActionResult>>(
-                Left: _ => new NotFoundResult().AsTask<IActionResult>(),
-                Right: async r =>
-                {
-                    HttpClient client = _httpClientFactory.CreateClient();
-                    client.DefaultRequestHeaders.Add("X-Plex-Token", r.AuthToken);
-
-                    var fullPath = new Uri(r.Uri, transcodePath);
-                    HttpResponseMessage response = await client.GetAsync(
-                        fullPath,
-                        HttpCompletionOption.ResponseHeadersRead,
-                        cancellationToken);
-                    Stream stream = await response.Content.ReadAsStreamAsync(cancellationToken);
-
-                    return new FileStreamResult(
-                        stream,
-                        response.Content.Headers.ContentType?.MediaType ?? "image/jpeg");
-                });
-        }
-
-        private async Task<IActionResult> GetJellyfinArtwork(string path, CancellationToken cancellationToken)
-        {
-            Either<BaseError, JellyfinConnectionParametersViewModel> connectionParameters =
-                await _mediator.Send(new GetJellyfinConnectionParameters(), cancellationToken);
-
-            return await connectionParameters.Match<Task<IActionResult>>(
-                Left: _ => new NotFoundResult().AsTask<IActionResult>(),
-                Right: async vm =>
-                {
-                    HttpClient client = _httpClientFactory.CreateClient();
-
-                    Url fullPath = JellyfinUrl.ForArtwork(vm.Address, path);
-                    HttpResponseMessage response = await client.GetAsync(
-                        fullPath,
-                        HttpCompletionOption.ResponseHeadersRead,
-                        cancellationToken);
-                    Stream stream = await response.Content.ReadAsStreamAsync(cancellationToken);
-
-                    return new FileStreamResult(
-                        stream,
-                        response.Content.Headers.ContentType?.MediaType ?? "image/jpeg");
-                });
-        }
-
-        private async Task<IActionResult> GetEmbyArtwork(string path, CancellationToken cancellationToken)
-        {
-            Either<BaseError, EmbyConnectionParametersViewModel> connectionParameters =
-                await _mediator.Send(new GetEmbyConnectionParameters(), cancellationToken);
-
-            return await connectionParameters.Match<Task<IActionResult>>(
-                Left: _ => new NotFoundResult().AsTask<IActionResult>(),
-                Right: async vm =>
-                {
-                    HttpClient client = _httpClientFactory.CreateClient();
-
-                    Url fullPath = EmbyUrl.ForArtwork(vm.Address, path);
-                    HttpResponseMessage response = await client.GetAsync(
-                        fullPath,
-                        HttpCompletionOption.ResponseHeadersRead,
-                        cancellationToken);
-                    Stream stream = await response.Content.ReadAsStreamAsync(cancellationToken);
-
-                    return new FileStreamResult(
-                        stream,
-                        response.Content.Headers.ContentType?.MediaType ?? "image/jpeg");
-                });
-        }
+        _mediator = mediator;
+        _httpClientFactory = httpClientFactory;
     }
-}
+
+    [HttpHead("/iptv/artwork/posters/{fileName}")]
+    [HttpGet("/iptv/artwork/posters/{fileName}")]
+    [HttpHead("/iptv/artwork/posters/{fileName}.jpg")]
+    [HttpGet("/iptv/artwork/posters/{fileName}.jpg")]
+    [HttpGet("/artwork/posters/{fileName}")]
+    public async Task<IActionResult> GetPoster(string fileName, CancellationToken cancellationToken)
+    {
+        Either<BaseError, CachedImagePathViewModel> cachedImagePath =
+            await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.Poster, 440), cancellationToken);
+        return cachedImagePath.Match<IActionResult>(
+            Left: _ => new NotFoundResult(),
+            Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
+    }
+
+    [HttpGet("/artwork/watermarks/{fileName}")]
+    public async Task<IActionResult> GetWatermark(string fileName, CancellationToken cancellationToken)
+    {
+        Either<BaseError, CachedImagePathViewModel> cachedImagePath =
+            await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.Watermark), cancellationToken);
+        return cachedImagePath.Match<IActionResult>(
+            Left: _ => new NotFoundResult(),
+            Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
+    }
+
+    [HttpGet("/artwork/fanart/{fileName}")]
+    public async Task<IActionResult> GetFanArt(string fileName, CancellationToken cancellationToken)
+    {
+        Either<BaseError, CachedImagePathViewModel> cachedImagePath =
+            await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.FanArt), cancellationToken);
+        return cachedImagePath.Match<IActionResult>(
+            Left: _ => new NotFoundResult(),
+            Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
+    }
+
+
+    [HttpHead("/iptv/artwork/posters/jellyfin/{*path}")]
+    [HttpGet("/iptv/artwork/posters/jellyfin/{*path}")]
+    [HttpGet("/artwork/posters/jellyfin/{*path}")]
+    [HttpHead("/iptv/artwork/thumbnails/jellyfin/{*path}")]
+    [HttpGet("/iptv/artwork/thumbnails/jellyfin/{*path}")]
+    [HttpGet("/artwork/thumbnails/jellyfin/{*path}")]
+    [HttpGet("/artwork/fanart/jellyfin/{*path}")]
+    public Task<IActionResult> GetJellyfin(string path, CancellationToken cancellationToken)
+    {
+        if (Request.QueryString.HasValue)
+        {
+            path += Request.QueryString.Value;
+        }
+
+        return GetJellyfinArtwork(path, cancellationToken);
+    }
+
+    [HttpHead("/iptv/artwork/posters/emby/{*path}")]
+    [HttpGet("/iptv/artwork/posters/emby/{*path}")]
+    [HttpGet("/artwork/posters/emby/{*path}")]
+    [HttpHead("/iptv/artwork/thumbnails/emby/{*path}")]
+    [HttpGet("/iptv/artwork/thumbnails/emby/{*path}")]
+    [HttpGet("/artwork/thumbnails/emby/{*path}")]
+    [HttpGet("/artwork/fanart/emby/{*path}")]
+    public Task<IActionResult> GetEmby(string path, CancellationToken cancellationToken)
+    {
+        if (Request.QueryString.HasValue)
+        {
+            path += Request.QueryString.Value;
+        }
+
+        return GetEmbyArtwork(path, cancellationToken);
+    }
+
+    [HttpHead("/iptv/artwork/posters/plex/{plexMediaSourceId}/{*path}")]
+    [HttpGet("/iptv/artwork/posters/plex/{plexMediaSourceId}/{*path}")]
+    [HttpGet("/artwork/posters/plex/{plexMediaSourceId}/{*path}")]
+    public Task<IActionResult> GetPlexPoster(int plexMediaSourceId, string path, CancellationToken cancellationToken) =>
+        GetPlexArtwork(
+            plexMediaSourceId,
+            $"photo/:/transcode?url=/{path}&height=440&width=304&minSize=1&upscale=0",
+            cancellationToken);
+
+    [HttpGet("/artwork/fanart/plex/{plexMediaSourceId}/{*path}")]
+    public Task<IActionResult> GetPlexFanArt(int plexMediaSourceId, string path, CancellationToken cancellationToken) =>
+        GetPlexArtwork(plexMediaSourceId, $"/{path}", cancellationToken);
+
+    [HttpGet("/artwork/thumbnails/plex/{plexMediaSourceId}/{*path}")]
+    public Task<IActionResult> GetPlexThumbnail(int plexMediaSourceId, string path, CancellationToken cancellationToken) =>
+        GetPlexArtwork(
+            plexMediaSourceId,
+            $"photo/:/transcode?url=/{path}&height=220&width=392&minSize=1&upscale=0",
+            cancellationToken);
+
+    [HttpHead("/iptv/artwork/thumbnails/{fileName}")]
+    [HttpGet("/iptv/artwork/thumbnails/{fileName}")]
+    [HttpHead("/iptv/artwork/thumbnails/{fileName}.jpg")]
+    [HttpGet("/iptv/artwork/thumbnails/{fileName}.jpg")]
+    [HttpGet("/artwork/thumbnails/{fileName}")]
+    public async Task<IActionResult> GetThumbnail(string fileName, CancellationToken cancellationToken)
+    {
+        Either<BaseError, CachedImagePathViewModel> cachedImagePath =
+            await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.Thumbnail, 220), cancellationToken);
+        return cachedImagePath.Match<IActionResult>(
+            Left: _ => new NotFoundResult(),
+            Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
+    }
+
+    private async Task<IActionResult> GetPlexArtwork(int plexMediaSourceId, string transcodePath, CancellationToken cancellationToken)
+    {
+        Either<BaseError, PlexConnectionParametersViewModel> connectionParameters =
+            await _mediator.Send(new GetPlexConnectionParameters(plexMediaSourceId), cancellationToken);
+
+        return await connectionParameters.Match<Task<IActionResult>>(
+            Left: _ => new NotFoundResult().AsTask<IActionResult>(),
+            Right: async r =>
+            {
+                HttpClient client = _httpClientFactory.CreateClient();
+                client.DefaultRequestHeaders.Add("X-Plex-Token", r.AuthToken);
+
+                var fullPath = new Uri(r.Uri, transcodePath);
+                HttpResponseMessage response = await client.GetAsync(
+                    fullPath,
+                    HttpCompletionOption.ResponseHeadersRead,
+                    cancellationToken);
+                Stream stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+
+                return new FileStreamResult(
+                    stream,
+                    response.Content.Headers.ContentType?.MediaType ?? "image/jpeg");
+            });
+    }
+
+    private async Task<IActionResult> GetJellyfinArtwork(string path, CancellationToken cancellationToken)
+    {
+        Either<BaseError, JellyfinConnectionParametersViewModel> connectionParameters =
+            await _mediator.Send(new GetJellyfinConnectionParameters(), cancellationToken);
+
+        return await connectionParameters.Match<Task<IActionResult>>(
+            Left: _ => new NotFoundResult().AsTask<IActionResult>(),
+            Right: async vm =>
+            {
+                HttpClient client = _httpClientFactory.CreateClient();
+
+                Url fullPath = JellyfinUrl.ForArtwork(vm.Address, path);
+                HttpResponseMessage response = await client.GetAsync(
+                    fullPath,
+                    HttpCompletionOption.ResponseHeadersRead,
+                    cancellationToken);
+                Stream stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+
+                return new FileStreamResult(
+                    stream,
+                    response.Content.Headers.ContentType?.MediaType ?? "image/jpeg");
+            });
+    }
+
+    private async Task<IActionResult> GetEmbyArtwork(string path, CancellationToken cancellationToken)
+    {
+        Either<BaseError, EmbyConnectionParametersViewModel> connectionParameters =
+            await _mediator.Send(new GetEmbyConnectionParameters(), cancellationToken);
+
+        return await connectionParameters.Match<Task<IActionResult>>(
+            Left: _ => new NotFoundResult().AsTask<IActionResult>(),
+            Right: async vm =>
+            {
+                HttpClient client = _httpClientFactory.CreateClient();
+
+                Url fullPath = EmbyUrl.ForArtwork(vm.Address, path);
+                HttpResponseMessage response = await client.GetAsync(
+                    fullPath,
+                    HttpCompletionOption.ResponseHeadersRead,
+                    cancellationToken);
+                Stream stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+
+                return new FileStreamResult(
+                    stream,
+                    response.Content.Headers.ContentType?.MediaType ?? "image/jpeg");
+            });
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Controllers/HdhrController.cs b/ErsatzTV/Controllers/HdhrController.cs
index af9a30e67..834223d04 100644
--- a/ErsatzTV/Controllers/HdhrController.cs
+++ b/ErsatzTV/Controllers/HdhrController.cs
@@ -1,38 +1,35 @@
-using System.Threading.Tasks;
-using ErsatzTV.Application.Channels.Queries;
-using ErsatzTV.Application.HDHR.Queries;
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Application.HDHR;
 using ErsatzTV.Core.Hdhr;
 using ErsatzTV.Extensions;
-using LanguageExt;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
 
-namespace ErsatzTV.Controllers
+namespace ErsatzTV.Controllers;
+
+[ApiController]
+[ApiExplorerSettings(IgnoreApi = true)]
+public class HdhrController : ControllerBase
 {
-    [ApiController]
-    [ApiExplorerSettings(IgnoreApi = true)]
-    public class HdhrController : ControllerBase
-    {
-        private readonly IMediator _mediator;
+    private readonly IMediator _mediator;
 
-        public HdhrController(IMediator mediator) => _mediator = mediator;
+    public HdhrController(IMediator mediator) => _mediator = mediator;
 
-        [HttpGet("device.xml")]
-        public IActionResult DeviceXml() =>
-            new OkObjectResult(new DeviceXml(Request.Scheme, Request.Host.ToString()));
+    [HttpGet("device.xml")]
+    public IActionResult DeviceXml() =>
+        new OkObjectResult(new DeviceXml(Request.Scheme, Request.Host.ToString()));
 
-        [HttpGet("discover.json")]
-        [ResponseCache(NoStore = true)]
-        public Task<IActionResult> Discover() =>
-            _mediator.Send(new GetHDHRTunerCount()).Map<int, IActionResult>(
-                tunerCount => new OkObjectResult(new Discover(Request.Scheme, Request.Host.ToString(), tunerCount)));
+    [HttpGet("discover.json")]
+    [ResponseCache(NoStore = true)]
+    public Task<IActionResult> Discover() =>
+        _mediator.Send(new GetHDHRTunerCount()).Map<int, IActionResult>(
+            tunerCount => new OkObjectResult(new Discover(Request.Scheme, Request.Host.ToString(), tunerCount)));
 
-        [HttpGet("lineup_status.json")]
-        public IActionResult LineupStatus() =>
-            new OkObjectResult(new LineupStatus());
+    [HttpGet("lineup_status.json")]
+    public IActionResult LineupStatus() =>
+        new OkObjectResult(new LineupStatus());
 
-        [HttpGet("lineup.json")]
-        public Task<IActionResult> Lineup() =>
-            _mediator.Send(new GetChannelLineup(Request.Scheme, Request.Host.ToString())).ToActionResult();
-    }
-}
+    [HttpGet("lineup.json")]
+    public Task<IActionResult> Lineup() =>
+        _mediator.Send(new GetChannelLineup(Request.Scheme, Request.Host.ToString())).ToActionResult();
+}
\ No newline at end of file
diff --git a/ErsatzTV/Controllers/InternalController.cs b/ErsatzTV/Controllers/InternalController.cs
index 1cb27844c..c59d9947e 100644
--- a/ErsatzTV/Controllers/InternalController.cs
+++ b/ErsatzTV/Controllers/InternalController.cs
@@ -1,68 +1,63 @@
-using System;
-using System.Diagnostics;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Streaming.Queries;
+using System.Diagnostics;
+using ErsatzTV.Application.Streaming;
 using ErsatzTV.Extensions;
-using LanguageExt;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Controllers
+namespace ErsatzTV.Controllers;
+
+[ApiController]
+[ApiExplorerSettings(IgnoreApi = true)]
+public class InternalController : ControllerBase
 {
-    [ApiController]
-    [ApiExplorerSettings(IgnoreApi = true)]
-    public class InternalController : ControllerBase
+    private readonly ILogger<InternalController> _logger;
+    private readonly IMediator _mediator;
+
+    public InternalController(IMediator mediator, ILogger<InternalController> logger)
     {
-        private readonly ILogger<InternalController> _logger;
-        private readonly IMediator _mediator;
-
-        public InternalController(IMediator mediator, ILogger<InternalController> logger)
-        {
-            _mediator = mediator;
-            _logger = logger;
-        }
-
-        [HttpGet("ffmpeg/concat/{channelNumber}")]
-        public Task<IActionResult> GetConcatPlaylist(string channelNumber) =>
-            _mediator.Send(new GetConcatPlaylistByChannelNumber(Request.Scheme, Request.Host.ToString(), channelNumber))
-                .ToActionResult();
-
-        [HttpGet("ffmpeg/stream/{channelNumber}")]
-        public Task<IActionResult> GetStream(
-            string channelNumber,
-            [FromQuery]
-            string mode = "mixed") =>
-            _mediator.Send(
-                    new GetPlayoutItemProcessByChannelNumber(
-                        channelNumber,
-                        mode,
-                        DateTimeOffset.Now,
-                        false,
-                        true,
-                        0,
-                        Option<int>.None))
-                .Map(
-                    result =>
-                        result.Match<IActionResult>(
-                            processModel =>
-                            {
-                                Process process = processModel.Process;
-
-                                _logger.LogInformation(
-                                    "ffmpeg arguments {FFmpegArguments}",
-                                    string.Join(" ", process.StartInfo.ArgumentList));
-                                process.Start();
-                                return new FileStreamResult(process.StandardOutput.BaseStream, "video/mp2t");
-                            },
-                            error =>
-                            {
-                                _logger.LogError(
-                                    "Failed to create stream for channel {ChannelNumber}: {Error}",
-                                    channelNumber,
-                                    error.Value);
-                                return BadRequest(error.Value);
-                            }
-                        ));
+        _mediator = mediator;
+        _logger = logger;
     }
-}
+
+    [HttpGet("ffmpeg/concat/{channelNumber}")]
+    public Task<IActionResult> GetConcatPlaylist(string channelNumber) =>
+        _mediator.Send(new GetConcatPlaylistByChannelNumber(Request.Scheme, Request.Host.ToString(), channelNumber))
+            .ToActionResult();
+
+    [HttpGet("ffmpeg/stream/{channelNumber}")]
+    public Task<IActionResult> GetStream(
+        string channelNumber,
+        [FromQuery]
+        string mode = "mixed") =>
+        _mediator.Send(
+                new GetPlayoutItemProcessByChannelNumber(
+                    channelNumber,
+                    mode,
+                    DateTimeOffset.Now,
+                    false,
+                    true,
+                    0,
+                    Option<int>.None))
+            .Map(
+                result =>
+                    result.Match<IActionResult>(
+                        processModel =>
+                        {
+                            Process process = processModel.Process;
+
+                            _logger.LogInformation(
+                                "ffmpeg arguments {FFmpegArguments}",
+                                string.Join(" ", process.StartInfo.ArgumentList));
+                            process.Start();
+                            return new FileStreamResult(process.StandardOutput.BaseStream, "video/mp2t");
+                        },
+                        error =>
+                        {
+                            _logger.LogError(
+                                "Failed to create stream for channel {ChannelNumber}: {Error}",
+                                channelNumber,
+                                error.Value);
+                            return BadRequest(error.Value);
+                        }
+                    ));
+}
\ No newline at end of file
diff --git a/ErsatzTV/Controllers/IptvController.cs b/ErsatzTV/Controllers/IptvController.cs
index b1d776db3..5e86a6a73 100644
--- a/ErsatzTV/Controllers/IptvController.cs
+++ b/ErsatzTV/Controllers/IptvController.cs
@@ -1,163 +1,154 @@
-using System;
 using System.Diagnostics;
-using System.IO;
-using System.Threading.Tasks;
-using ErsatzTV.Application.Channels.Queries;
+using ErsatzTV.Application.Channels;
 using ErsatzTV.Application.Images;
-using ErsatzTV.Application.Images.Queries;
-using ErsatzTV.Application.Streaming.Commands;
-using ErsatzTV.Application.Streaming.Queries;
+using ErsatzTV.Application.Streaming;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
 using ErsatzTV.Core.FFmpeg;
 using ErsatzTV.Core.Interfaces.FFmpeg;
 using ErsatzTV.Core.Iptv;
-using LanguageExt;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Controllers
+namespace ErsatzTV.Controllers;
+
+[ApiController]
+[ApiExplorerSettings(IgnoreApi = true)]
+public class IptvController : ControllerBase
 {
-    [ApiController]
-    [ApiExplorerSettings(IgnoreApi = true)]
-    public class IptvController : ControllerBase
+    private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
+    private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
+    private readonly ILogger<IptvController> _logger;
+    private readonly IMediator _mediator;
+
+    public IptvController(
+        IMediator mediator,
+        ILogger<IptvController> logger,
+        IFFmpegSegmenterService ffmpegSegmenterService,
+        IHlsPlaylistFilter hlsPlaylistFilter)
     {
-        private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
-        private readonly IHlsPlaylistFilter _hlsPlaylistFilter;
-        private readonly ILogger<IptvController> _logger;
-        private readonly IMediator _mediator;
+        _mediator = mediator;
+        _logger = logger;
+        _ffmpegSegmenterService = ffmpegSegmenterService;
+        _hlsPlaylistFilter = hlsPlaylistFilter;
+    }
 
-        public IptvController(
-            IMediator mediator,
-            ILogger<IptvController> logger,
-            IFFmpegSegmenterService ffmpegSegmenterService,
-            IHlsPlaylistFilter hlsPlaylistFilter)
+    [HttpGet("iptv/channels.m3u")]
+    public Task<IActionResult> GetChannelPlaylist(
+        [FromQuery]
+        string mode = "mixed") =>
+        _mediator.Send(new GetChannelPlaylist(Request.Scheme, Request.Host.ToString(), mode))
+            .Map<ChannelPlaylist, IActionResult>(Ok);
+
+    [HttpGet("iptv/xmltv.xml")]
+    public Task<IActionResult> GetGuide() =>
+        _mediator.Send(new GetChannelGuide(Request.Scheme, Request.Host.ToString()))
+            .Map<ChannelGuide, IActionResult>(Ok);
+
+    [HttpGet("iptv/channel/{channelNumber}.ts")]
+    public async Task<IActionResult> GetTransportStreamVideo(
+        string channelNumber,
+        [FromQuery]
+        string mode = null)
+    {
+        FFmpegProcessRequest request = mode switch
         {
-            _mediator = mediator;
-            _logger = logger;
-            _ffmpegSegmenterService = ffmpegSegmenterService;
-            _hlsPlaylistFilter = hlsPlaylistFilter;
-        }
+            "ts-legacy" => new GetConcatProcessByChannelNumber(Request.Scheme, Request.Host.ToString(), channelNumber),
+            _ => new GetWrappedProcessByChannelNumber(Request.Scheme, Request.Host.ToString(), channelNumber)
+        };
 
-        [HttpGet("iptv/channels.m3u")]
-        public Task<IActionResult> GetChannelPlaylist(
-            [FromQuery]
-            string mode = "mixed") =>
-            _mediator.Send(new GetChannelPlaylist(Request.Scheme, Request.Host.ToString(), mode))
-                .Map<ChannelPlaylist, IActionResult>(Ok);
+        return await _mediator.Send(request)
+            .Map(
+                result => result.Match<IActionResult>(
+                    processModel =>
+                    {
+                        Process process = processModel.Process;
 
-        [HttpGet("iptv/xmltv.xml")]
-        public Task<IActionResult> GetGuide() =>
-            _mediator.Send(new GetChannelGuide(Request.Scheme, Request.Host.ToString()))
-                .Map<ChannelGuide, IActionResult>(Ok);
+                        _logger.LogInformation("Starting ts stream for channel {ChannelNumber}", channelNumber);
+                        // _logger.LogDebug(
+                        //     "ffmpeg concat arguments {FFmpegArguments}",
+                        //     string.Join(" ", process.StartInfo.ArgumentList));
+                        process.Start();
+                        return new FileStreamResult(process.StandardOutput.BaseStream, "video/mp2t");
+                    },
+                    error => BadRequest(error.Value)));
+    }
 
-        [HttpGet("iptv/channel/{channelNumber}.ts")]
-        public async Task<IActionResult> GetTransportStreamVideo(
-            string channelNumber,
-            [FromQuery]
-            string mode = null)
+    [HttpGet("iptv/session/{channelNumber}/hls.m3u8")]
+    public async Task<IActionResult> GetLivePlaylist(string channelNumber)
+    {
+        if (_ffmpegSegmenterService.SessionWorkers.TryGetValue(channelNumber, out IHlsSessionWorker worker))
         {
-            FFmpegProcessRequest request = mode switch
-            {
-                "ts-legacy" => new GetConcatProcessByChannelNumber(Request.Scheme, Request.Host.ToString(), channelNumber),
-                _ => new GetWrappedProcessByChannelNumber(Request.Scheme, Request.Host.ToString(), channelNumber)
-            };
-
-            return await _mediator.Send(request)
-                .Map(
-                    result => result.Match<IActionResult>(
-                        processModel =>
-                        {
-                            Process process = processModel.Process;
-
-                            _logger.LogInformation("Starting ts stream for channel {ChannelNumber}", channelNumber);
-                            // _logger.LogDebug(
-                            //     "ffmpeg concat arguments {FFmpegArguments}",
-                            //     string.Join(" ", process.StartInfo.ArgumentList));
-                            process.Start();
-                            return new FileStreamResult(process.StandardOutput.BaseStream, "video/mp2t");
-                        },
-                        error => BadRequest(error.Value)));
-        }
-
-        [HttpGet("iptv/session/{channelNumber}/hls.m3u8")]
-        public async Task<IActionResult> GetLivePlaylist(string channelNumber)
-        {
-            if (_ffmpegSegmenterService.SessionWorkers.TryGetValue(channelNumber, out IHlsSessionWorker worker))
-            {
-                DateTimeOffset now = DateTimeOffset.Now.AddSeconds(-30);
+            DateTimeOffset now = DateTimeOffset.Now.AddSeconds(-30);
             
-                string fileName = Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber, "live.m3u8");
-                if (System.IO.File.Exists(fileName))
-                {
-                    string[] input = await System.IO.File.ReadAllLinesAsync(fileName);
-
-                    // _logger.LogInformation(
-                    //     "Trimming playlist: {PlaylistStart} {FilterBefore}",
-                    //     worker.PlaylistStart,
-                    //     now);
-
-                    TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(worker.PlaylistStart, now, input);
-                    return Content(result.Playlist, "application/vnd.apple.mpegurl");
-                }
-            }
-
-            return NotFound();
-        }
-
-        [HttpGet("iptv/channel/{channelNumber}.m3u8")]
-        public async Task<IActionResult> GetHttpLiveStreamingVideo(
-            string channelNumber,
-            [FromQuery]
-            string mode = "mixed")
-        {
-            switch (mode)
+            string fileName = Path.Combine(FileSystemLayout.TranscodeFolder, channelNumber, "live.m3u8");
+            if (System.IO.File.Exists(fileName))
             {
-                case "segmenter":
-                    Either<BaseError, Unit> result = await _mediator.Send(new StartFFmpegSession(channelNumber, false));
-                    return result.Match<IActionResult>(
-                        _ => Redirect($"/iptv/session/{channelNumber}/hls.m3u8"),
-                        error =>
-                        {
-                            switch (error)
-                            {
-                                case ChannelSessionAlreadyActive:
-                                    return RedirectPreserveMethod($"/iptv/session/{channelNumber}/hls.m3u8");
-                                default:
-                                    _logger.LogWarning(
-                                        "Failed to start segmenter for channel {ChannelNumber}: {Error}",
-                                        channelNumber,
-                                        error.ToString());
-                                    return NotFound();
-                            }
-                        });
-                default:
-                    return await _mediator.Send(
-                            new GetHlsPlaylistByChannelNumber(
-                                Request.Scheme,
-                                Request.Host.ToString(),
-                                channelNumber,
-                                mode))
-                        .Map(
-                            r => r.Match<IActionResult>(
-                                playlist => Content(playlist, "application/x-mpegurl"),
-                                error => BadRequest(error.Value)));
+                string[] input = await System.IO.File.ReadAllLinesAsync(fileName);
+
+                // _logger.LogInformation(
+                //     "Trimming playlist: {PlaylistStart} {FilterBefore}",
+                //     worker.PlaylistStart,
+                //     now);
+
+                TrimPlaylistResult result = _hlsPlaylistFilter.TrimPlaylist(worker.PlaylistStart, now, input);
+                return Content(result.Playlist, "application/vnd.apple.mpegurl");
             }
         }
 
-        [HttpGet("iptv/logos/{fileName}")]
-        [HttpHead("iptv/logos/{fileName}.jpg")]
-        [HttpGet("iptv/logos/{fileName}.jpg")]
-        public async Task<IActionResult> GetImage(string fileName)
+        return NotFound();
+    }
+
+    [HttpGet("iptv/channel/{channelNumber}.m3u8")]
+    public async Task<IActionResult> GetHttpLiveStreamingVideo(
+        string channelNumber,
+        [FromQuery]
+        string mode = "mixed")
+    {
+        switch (mode)
         {
-            Either<BaseError, CachedImagePathViewModel> cachedImagePath =
-                await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.Logo));
-            return cachedImagePath.Match<IActionResult>(
-                Left: _ => new NotFoundResult(),
-                Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
+            case "segmenter":
+                Either<BaseError, Unit> result = await _mediator.Send(new StartFFmpegSession(channelNumber, false));
+                return result.Match<IActionResult>(
+                    _ => Redirect($"/iptv/session/{channelNumber}/hls.m3u8"),
+                    error =>
+                    {
+                        switch (error)
+                        {
+                            case ChannelSessionAlreadyActive:
+                                return RedirectPreserveMethod($"/iptv/session/{channelNumber}/hls.m3u8");
+                            default:
+                                _logger.LogWarning(
+                                    "Failed to start segmenter for channel {ChannelNumber}: {Error}",
+                                    channelNumber,
+                                    error.ToString());
+                                return NotFound();
+                        }
+                    });
+            default:
+                return await _mediator.Send(
+                        new GetHlsPlaylistByChannelNumber(
+                            Request.Scheme,
+                            Request.Host.ToString(),
+                            channelNumber,
+                            mode))
+                    .Map(
+                        r => r.Match<IActionResult>(
+                            playlist => Content(playlist, "application/x-mpegurl"),
+                            error => BadRequest(error.Value)));
         }
     }
-}
+
+    [HttpGet("iptv/logos/{fileName}")]
+    [HttpHead("iptv/logos/{fileName}.jpg")]
+    [HttpGet("iptv/logos/{fileName}.jpg")]
+    public async Task<IActionResult> GetImage(string fileName)
+    {
+        Either<BaseError, CachedImagePathViewModel> cachedImagePath =
+            await _mediator.Send(new GetCachedImagePath(fileName, ArtworkKind.Logo));
+        return cachedImagePath.Match<IActionResult>(
+            Left: _ => new NotFoundResult(),
+            Right: r => new PhysicalFileResult(r.FileName, r.MimeType));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Controllers/SortController.cs b/ErsatzTV/Controllers/SortController.cs
index ff2ea4628..051431394 100644
--- a/ErsatzTV/Controllers/SortController.cs
+++ b/ErsatzTV/Controllers/SortController.cs
@@ -1,35 +1,31 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCollections.Commands;
+using ErsatzTV.Application.MediaCollections;
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
 
-namespace ErsatzTV.Controllers
+namespace ErsatzTV.Controllers;
+
+[ApiController]
+[ApiExplorerSettings(IgnoreApi = true)]
+public class SortController : ControllerBase
 {
-    [ApiController]
-    [ApiExplorerSettings(IgnoreApi = true)]
-    public class SortController : ControllerBase
+    private readonly IMediator _mediator;
+
+    public SortController(IMediator mediator) => _mediator = mediator;
+
+    [HttpPost("media/collections/{collectionId}/items")]
+    public Task SortCollectionItems(
+        int collectionId,
+        [FromForm]
+        SortedMediaItemIds sortedMediaItemIds)
     {
-        private readonly IMediator _mediator;
+        var ids = sortedMediaItemIds.Item.Map(int.Parse).ToList();
 
-        public SortController(IMediator mediator) => _mediator = mediator;
+        var request = new UpdateCollectionCustomOrder(
+            collectionId,
+            ids.Map(i => new MediaItemCustomOrder(i, ids.IndexOf(i))).ToList());
 
-        [HttpPost("media/collections/{collectionId}/items")]
-        public Task SortCollectionItems(
-            int collectionId,
-            [FromForm]
-            SortedMediaItemIds sortedMediaItemIds)
-        {
-            var ids = sortedMediaItemIds.Item.Map(int.Parse).ToList();
-
-            var request = new UpdateCollectionCustomOrder(
-                collectionId,
-                ids.Map(i => new MediaItemCustomOrder(i, ids.IndexOf(i))).ToList());
-
-            return _mediator.Send(request);
-        }
+        return _mediator.Send(request);
     }
-
-    public record SortedMediaItemIds(List<string> Item);
 }
+
+public record SortedMediaItemIds(List<string> Item);
\ No newline at end of file
diff --git a/ErsatzTV/ErsatzTV.csproj b/ErsatzTV/ErsatzTV.csproj
index 0ee0d9881..392d8f062 100644
--- a/ErsatzTV/ErsatzTV.csproj
+++ b/ErsatzTV/ErsatzTV.csproj
@@ -2,6 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net6.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
         <NoWarn>VSTHRD200</NoWarn>
         <IncludeAllContentForSelfExtract>true</IncludeAllContentForSelfExtract>
     </PropertyGroup>
diff --git a/ErsatzTV/Extensions/EitherToActionResult.cs b/ErsatzTV/Extensions/EitherToActionResult.cs
index df71dc988..f5b23d06e 100644
--- a/ErsatzTV/Extensions/EitherToActionResult.cs
+++ b/ErsatzTV/Extensions/EitherToActionResult.cs
@@ -1,30 +1,27 @@
 using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
-using LanguageExt;
 using LanguageExt.Common;
 using Microsoft.AspNetCore.Mvc;
 
-namespace ErsatzTV.Extensions
+namespace ErsatzTV.Extensions;
+
+[SuppressMessage("ReSharper", "VSTHRD003")]
+public static class EitherToActionResult
 {
-    [SuppressMessage("ReSharper", "VSTHRD003")]
-    public static class EitherToActionResult
-    {
-        public static Task<IActionResult> ToActionResult<TL, TR>(this Task<Either<TL, TR>> either) => either.Map(Match);
+    public static Task<IActionResult> ToActionResult<TL, TR>(this Task<Either<TL, TR>> either) => either.Map(Match);
 
-        public static Task<IActionResult> ToActionResult(this Task<Either<Error, Task>> either) => either.Bind(Match);
+    public static Task<IActionResult> ToActionResult(this Task<Either<Error, Task>> either) => either.Bind(Match);
 
-        private static IActionResult Match<TL, TR>(this Either<TL, TR> either) =>
-            either.Match<IActionResult>(
-                Left: l => new BadRequestObjectResult(l),
-                Right: r => new OkObjectResult(r));
+    private static IActionResult Match<TL, TR>(this Either<TL, TR> either) =>
+        either.Match<IActionResult>(
+            Left: l => new BadRequestObjectResult(l),
+            Right: r => new OkObjectResult(r));
 
-        private static Task<IActionResult> Match(Either<Error, Task> either) =>
-            either.Match<Task<IActionResult>>(
-                async t =>
-                {
-                    await t;
-                    return new OkResult();
-                },
-                e => Task.FromResult((IActionResult) new BadRequestObjectResult(e)));
-    }
-}
+    private static Task<IActionResult> Match(Either<Error, Task> either) =>
+        either.Match<Task<IActionResult>>(
+            async t =>
+            {
+                await t;
+                return new OkResult();
+            },
+            e => Task.FromResult((IActionResult) new BadRequestObjectResult(e)));
+}
\ No newline at end of file
diff --git a/ErsatzTV/Extensions/ListToActionResult.cs b/ErsatzTV/Extensions/ListToActionResult.cs
index edd416125..d6cde7eb9 100644
--- a/ErsatzTV/Extensions/ListToActionResult.cs
+++ b/ErsatzTV/Extensions/ListToActionResult.cs
@@ -1,15 +1,11 @@
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
-using LanguageExt;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.AspNetCore.Mvc;
 
-namespace ErsatzTV.Extensions
+namespace ErsatzTV.Extensions;
+
+[SuppressMessage("ReSharper", "VSTHRD003")]
+public static class ListToActionResult
 {
-    [SuppressMessage("ReSharper", "VSTHRD003")]
-    public static class ListToActionResult
-    {
-        public static Task<IActionResult> ToActionResult<T>(this Task<List<T>> list) =>
-            list.Map<List<T>, IActionResult>(l => new OkObjectResult(l));
-    }
-}
+    public static Task<IActionResult> ToActionResult<T>(this Task<List<T>> list) =>
+        list.Map<List<T>, IActionResult>(l => new OkObjectResult(l));
+}
\ No newline at end of file
diff --git a/ErsatzTV/Extensions/NavigationManagerExtensions.cs b/ErsatzTV/Extensions/NavigationManagerExtensions.cs
index 1597b2254..9b61cfa65 100644
--- a/ErsatzTV/Extensions/NavigationManagerExtensions.cs
+++ b/ErsatzTV/Extensions/NavigationManagerExtensions.cs
@@ -1,22 +1,19 @@
-using System;
-using System.Threading.Tasks;
-using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components;
 using Microsoft.JSInterop;
 
-namespace ErsatzTV.Extensions
+namespace ErsatzTV.Extensions;
+
+public static class NavigationManagerExtensions
 {
-    public static class NavigationManagerExtensions
+    public static ValueTask NavigateToFragmentAsync(this NavigationManager navigationManager, IJSRuntime jSRuntime)
     {
-        public static ValueTask NavigateToFragmentAsync(this NavigationManager navigationManager, IJSRuntime jSRuntime)
+        Uri uri = navigationManager.ToAbsoluteUri(navigationManager.Uri);
+
+        if (uri.Fragment.Length == 0)
         {
-            Uri uri = navigationManager.ToAbsoluteUri(navigationManager.Uri);
-
-            if (uri.Fragment.Length == 0)
-            {
-                return default;
-            }
-
-            return jSRuntime.InvokeVoidAsync("blazorHelpers.scrollToFragment", uri.Fragment.Substring(1));
+            return default;
         }
+
+        return jSRuntime.InvokeVoidAsync("blazorHelpers.scrollToFragment", uri.Fragment.Substring(1));
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Extensions/OptionToActionResult.cs b/ErsatzTV/Extensions/OptionToActionResult.cs
index 021dbc6eb..1101d33e1 100644
--- a/ErsatzTV/Extensions/OptionToActionResult.cs
+++ b/ErsatzTV/Extensions/OptionToActionResult.cs
@@ -1,18 +1,15 @@
 using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
-using LanguageExt;
 using Microsoft.AspNetCore.Mvc;
 
-namespace ErsatzTV.Extensions
-{
-    [SuppressMessage("ReSharper", "VSTHRD003")]
-    public static class OptionToActionResult
-    {
-        public static IActionResult ToActionResult<T>(this Option<T> option) =>
-            option.Match<IActionResult>(
-                t => new OkObjectResult(t),
-                () => new NotFoundResult());
+namespace ErsatzTV.Extensions;
 
-        public static Task<IActionResult> ToActionResult<T>(this Task<Option<T>> option) => option.Map(ToActionResult);
-    }
-}
+[SuppressMessage("ReSharper", "VSTHRD003")]
+public static class OptionToActionResult
+{
+    public static IActionResult ToActionResult<T>(this Option<T> option) =>
+        option.Match<IActionResult>(
+            t => new OkObjectResult(t),
+            () => new NotFoundResult());
+
+    public static Task<IActionResult> ToActionResult<T>(this Task<Option<T>> option) => option.Map(ToActionResult);
+}
\ No newline at end of file
diff --git a/ErsatzTV/Extensions/StringExtensions.cs b/ErsatzTV/Extensions/StringExtensions.cs
index 9949cdd87..5c2e0a0e4 100644
--- a/ErsatzTV/Extensions/StringExtensions.cs
+++ b/ErsatzTV/Extensions/StringExtensions.cs
@@ -1,68 +1,65 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Text;
 using Microsoft.AspNetCore.WebUtilities;
 using Microsoft.Extensions.Primitives;
 
-namespace ErsatzTV.Extensions
+namespace ErsatzTV.Extensions;
+
+public static class StringExtensions
 {
-    public static class StringExtensions
+    public static string GetSearchQuery(this string uri)
     {
-        public static string GetSearchQuery(this string uri)
+        try
         {
-            try
+            string query = new Uri(uri).Query;
+            Dictionary<string, StringValues> parsed = QueryHelpers.ParseQuery(query);
+            if (parsed.TryGetValue("query", out StringValues value))
             {
-                string query = new Uri(uri).Query;
-                Dictionary<string, StringValues> parsed = QueryHelpers.ParseQuery(query);
-                if (parsed.TryGetValue("query", out StringValues value))
-                {
-                    return value;
-                }
-
-                if (parsed.TryGetValue("b64query", out StringValues base64Value))
-                {
-                    return base64Value.DecodeBase64();
-                }
-            }
-            catch (Exception)
-            {
-                // do nothing
+                return value;
             }
 
-            return string.Empty;
+            if (parsed.TryGetValue("b64query", out StringValues base64Value))
+            {
+                return base64Value.DecodeBase64();
+            }
         }
-
-        public static string GetRelativeSearchQuery(this string query)
+        catch (Exception)
         {
-            (string key, string value) = EncodeQuery(query);
-            return $"/search?{key}={value}";
+            // do nothing
         }
 
-        private static string DecodeBase64(this StringValues input) =>
-            Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(input));
-
-        public static EncodedQueryResult EncodeQuery(this string query)
-        {
-            string normalizedQuery = Normalize(query);
-            
-            string encoded = Uri.EscapeDataString(normalizedQuery);
-
-            // TODO: remove this on dotnet 6
-            // see https://github.com/dotnet/aspnetcore/pull/26769
-            var fakeAbsolute = $"https://whatever.com/test?query={encoded}";
-            return Uri.IsWellFormedUriString(fakeAbsolute, UriKind.Absolute)
-                ? new EncodedQueryResult("query", encoded)
-                : new EncodedQueryResult("b64query", WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(query)));
-        }
-
-        public record EncodedQueryResult(string Key, string Value);
-
-        private static string Normalize(string s)
-        {
-            // normalize single and double quotes
-            return !string.IsNullOrEmpty(s)
-                ? s.Replace('\u2018', '\'').Replace('\u2019', '\'').Replace('\u201c', '\"').Replace('\u201d', '\"')
-                : s;
-        }
+        return string.Empty;
     }
-}
+
+    public static string GetRelativeSearchQuery(this string query)
+    {
+        (string key, string value) = EncodeQuery(query);
+        return $"/search?{key}={value}";
+    }
+
+    private static string DecodeBase64(this StringValues input) =>
+        Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(input));
+
+    public static EncodedQueryResult EncodeQuery(this string query)
+    {
+        string normalizedQuery = Normalize(query);
+            
+        string encoded = Uri.EscapeDataString(normalizedQuery);
+
+        // TODO: remove this on dotnet 6
+        // see https://github.com/dotnet/aspnetcore/pull/26769
+        var fakeAbsolute = $"https://whatever.com/test?query={encoded}";
+        return Uri.IsWellFormedUriString(fakeAbsolute, UriKind.Absolute)
+            ? new EncodedQueryResult("query", encoded)
+            : new EncodedQueryResult("b64query", WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(query)));
+    }
+
+    public record EncodedQueryResult(string Key, string Value);
+
+    private static string Normalize(string s)
+    {
+        // normalize single and double quotes
+        return !string.IsNullOrEmpty(s)
+            ? s.Replace('\u2018', '\'').Replace('\u2019', '\'').Replace('\u201c', '\"').Replace('\u201d', '\"')
+            : s;
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Extensions/ValidationToActionResult.cs b/ErsatzTV/Extensions/ValidationToActionResult.cs
index afd6c50cc..a7b778c75 100644
--- a/ErsatzTV/Extensions/ValidationToActionResult.cs
+++ b/ErsatzTV/Extensions/ValidationToActionResult.cs
@@ -1,32 +1,29 @@
 using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
-using LanguageExt;
 using Microsoft.AspNetCore.Mvc;
 
-namespace ErsatzTV.Extensions
+namespace ErsatzTV.Extensions;
+
+[SuppressMessage("ReSharper", "VSTHRD003")]
+public static class ValidationToActionResult
 {
-    [SuppressMessage("ReSharper", "VSTHRD003")]
-    public static class ValidationToActionResult
-    {
-        public static IActionResult ToActionResult<T>(this Validation<BaseError, T> validation) =>
-            validation.Match<IActionResult>(
-                t => new OkObjectResult(t),
-                e => new BadRequestObjectResult(e));
+    public static IActionResult ToActionResult<T>(this Validation<BaseError, T> validation) =>
+        validation.Match<IActionResult>(
+            t => new OkObjectResult(t),
+            e => new BadRequestObjectResult(e));
 
-        public static Task<IActionResult> ToActionResult<T>(this Task<Validation<BaseError, T>> validation) =>
-            validation.Map(ToActionResult);
+    public static Task<IActionResult> ToActionResult<T>(this Task<Validation<BaseError, T>> validation) =>
+        validation.Map(ToActionResult);
 
-        public static Task<IActionResult> ToActionResult(this Task<Validation<BaseError, Task>> validation) =>
-            validation.Bind(ToActionResult);
+    public static Task<IActionResult> ToActionResult(this Task<Validation<BaseError, Task>> validation) =>
+        validation.Bind(ToActionResult);
 
-        private static Task<IActionResult> ToActionResult(Validation<BaseError, Task> validation) =>
-            validation.MatchAsync<IActionResult>(
-                async t =>
-                {
-                    await t;
-                    return new OkResult();
-                },
-                e => new BadRequestObjectResult(e));
-    }
-}
+    private static Task<IActionResult> ToActionResult(Validation<BaseError, Task> validation) =>
+        validation.MatchAsync<IActionResult>(
+            async t =>
+            {
+                await t;
+                return new OkResult();
+            },
+            e => new BadRequestObjectResult(e));
+}
\ No newline at end of file
diff --git a/ErsatzTV/Formatters/ChannelGuideOutputFormatter.cs b/ErsatzTV/Formatters/ChannelGuideOutputFormatter.cs
index a1eb9cf77..64c6bb00d 100644
--- a/ErsatzTV/Formatters/ChannelGuideOutputFormatter.cs
+++ b/ErsatzTV/Formatters/ChannelGuideOutputFormatter.cs
@@ -1,27 +1,23 @@
-using System;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.Iptv;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Net.Http.Headers;
 
-namespace ErsatzTV.Formatters
+namespace ErsatzTV.Formatters;
+
+public class ChannelGuideOutputFormatter : TextOutputFormatter
 {
-    public class ChannelGuideOutputFormatter : TextOutputFormatter
+    public ChannelGuideOutputFormatter()
     {
-        public ChannelGuideOutputFormatter()
-        {
-            SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/xml"));
+        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/xml"));
 
-            SupportedEncodings.Add(Encoding.UTF8);
-            SupportedEncodings.Add(Encoding.Unicode);
-        }
-
-        protected override bool CanWriteType(Type type) => typeof(ChannelGuide).IsAssignableFrom(type);
-
-        public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
-            // ReSharper disable once PossibleNullReferenceException
-            context.HttpContext.Response.WriteAsync(((ChannelGuide) context.Object).ToXml());
+        SupportedEncodings.Add(Encoding.UTF8);
+        SupportedEncodings.Add(Encoding.Unicode);
     }
-}
+
+    protected override bool CanWriteType(Type type) => typeof(ChannelGuide).IsAssignableFrom(type);
+
+    public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
+        // ReSharper disable once PossibleNullReferenceException
+        context.HttpContext.Response.WriteAsync(((ChannelGuide) context.Object).ToXml());
+}
\ No newline at end of file
diff --git a/ErsatzTV/Formatters/ChannelPlaylistOutputFormatter.cs b/ErsatzTV/Formatters/ChannelPlaylistOutputFormatter.cs
index 59e90390a..a1d154bd8 100644
--- a/ErsatzTV/Formatters/ChannelPlaylistOutputFormatter.cs
+++ b/ErsatzTV/Formatters/ChannelPlaylistOutputFormatter.cs
@@ -1,27 +1,23 @@
-using System;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.Iptv;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Net.Http.Headers;
 
-namespace ErsatzTV.Formatters
+namespace ErsatzTV.Formatters;
+
+public class ChannelPlaylistOutputFormatter : TextOutputFormatter
 {
-    public class ChannelPlaylistOutputFormatter : TextOutputFormatter
+    public ChannelPlaylistOutputFormatter()
     {
-        public ChannelPlaylistOutputFormatter()
-        {
-            SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/x-mpegurl"));
+        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/x-mpegurl"));
 
-            SupportedEncodings.Add(Encoding.UTF8);
-            SupportedEncodings.Add(Encoding.Unicode);
-        }
-
-        protected override bool CanWriteType(Type type) => typeof(ChannelPlaylist).IsAssignableFrom(type);
-
-        public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
-            // ReSharper disable once PossibleNullReferenceException
-            context.HttpContext.Response.WriteAsync(((ChannelPlaylist) context.Object).ToM3U());
+        SupportedEncodings.Add(Encoding.UTF8);
+        SupportedEncodings.Add(Encoding.Unicode);
     }
-}
+
+    protected override bool CanWriteType(Type type) => typeof(ChannelPlaylist).IsAssignableFrom(type);
+
+    public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
+        // ReSharper disable once PossibleNullReferenceException
+        context.HttpContext.Response.WriteAsync(((ChannelPlaylist) context.Object).ToM3U());
+}
\ No newline at end of file
diff --git a/ErsatzTV/Formatters/ConcatPlaylistOutputFormatter.cs b/ErsatzTV/Formatters/ConcatPlaylistOutputFormatter.cs
index b03fdc121..806d6de2d 100644
--- a/ErsatzTV/Formatters/ConcatPlaylistOutputFormatter.cs
+++ b/ErsatzTV/Formatters/ConcatPlaylistOutputFormatter.cs
@@ -1,27 +1,23 @@
-using System;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.FFmpeg;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Net.Http.Headers;
 
-namespace ErsatzTV.Formatters
+namespace ErsatzTV.Formatters;
+
+public class ConcatPlaylistOutputFormatter : TextOutputFormatter
 {
-    public class ConcatPlaylistOutputFormatter : TextOutputFormatter
+    public ConcatPlaylistOutputFormatter()
     {
-        public ConcatPlaylistOutputFormatter()
-        {
-            SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/plain"));
+        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/plain"));
 
-            SupportedEncodings.Add(Encoding.UTF8);
-            SupportedEncodings.Add(Encoding.Unicode);
-        }
-
-        protected override bool CanWriteType(Type type) => typeof(ConcatPlaylist).IsAssignableFrom(type);
-
-        public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
-            // ReSharper disable once PossibleNullReferenceException
-            context.HttpContext.Response.WriteAsync(((ConcatPlaylist) context.Object).ToString());
+        SupportedEncodings.Add(Encoding.UTF8);
+        SupportedEncodings.Add(Encoding.Unicode);
     }
-}
+
+    protected override bool CanWriteType(Type type) => typeof(ConcatPlaylist).IsAssignableFrom(type);
+
+    public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
+        // ReSharper disable once PossibleNullReferenceException
+        context.HttpContext.Response.WriteAsync(((ConcatPlaylist) context.Object).ToString());
+}
\ No newline at end of file
diff --git a/ErsatzTV/Formatters/DeviceXmlOutputFormatter.cs b/ErsatzTV/Formatters/DeviceXmlOutputFormatter.cs
index 33eddbd1b..42ad88b27 100644
--- a/ErsatzTV/Formatters/DeviceXmlOutputFormatter.cs
+++ b/ErsatzTV/Formatters/DeviceXmlOutputFormatter.cs
@@ -1,27 +1,23 @@
-using System;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.Hdhr;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Net.Http.Headers;
 
-namespace ErsatzTV.Formatters
+namespace ErsatzTV.Formatters;
+
+public class DeviceXmlOutputFormatter : TextOutputFormatter
 {
-    public class DeviceXmlOutputFormatter : TextOutputFormatter
+    public DeviceXmlOutputFormatter()
     {
-        public DeviceXmlOutputFormatter()
-        {
-            SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/xml"));
+        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/xml"));
 
-            SupportedEncodings.Add(Encoding.UTF8);
-            SupportedEncodings.Add(Encoding.Unicode);
-        }
-
-        protected override bool CanWriteType(Type type) => typeof(DeviceXml).IsAssignableFrom(type);
-
-        public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
-            // ReSharper disable once PossibleNullReferenceException
-            context.HttpContext.Response.WriteAsync(((DeviceXml) context.Object).ToXml());
+        SupportedEncodings.Add(Encoding.UTF8);
+        SupportedEncodings.Add(Encoding.Unicode);
     }
-}
+
+    protected override bool CanWriteType(Type type) => typeof(DeviceXml).IsAssignableFrom(type);
+
+    public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
+        // ReSharper disable once PossibleNullReferenceException
+        context.HttpContext.Response.WriteAsync(((DeviceXml) context.Object).ToXml());
+}
\ No newline at end of file
diff --git a/ErsatzTV/Formatters/HdhrJsonOutputFormatter.cs b/ErsatzTV/Formatters/HdhrJsonOutputFormatter.cs
index a5de3ac28..8530cf16a 100644
--- a/ErsatzTV/Formatters/HdhrJsonOutputFormatter.cs
+++ b/ErsatzTV/Formatters/HdhrJsonOutputFormatter.cs
@@ -1,43 +1,38 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
+using System.Text;
 using ErsatzTV.Core.Hdhr;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Formatters;
 using Microsoft.Net.Http.Headers;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 
-namespace ErsatzTV.Formatters
+namespace ErsatzTV.Formatters;
+
+public class HdhrJsonOutputFormatter : TextOutputFormatter
 {
-    public class HdhrJsonOutputFormatter : TextOutputFormatter
+    private readonly JsonSerializerSettings _jsonSerializerSettings;
+
+    public HdhrJsonOutputFormatter()
     {
-        private readonly JsonSerializerSettings _jsonSerializerSettings;
+        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
 
-        public HdhrJsonOutputFormatter()
+        SupportedEncodings.Add(Encoding.UTF8);
+        SupportedEncodings.Add(Encoding.Unicode);
+
+        _jsonSerializerSettings = new JsonSerializerSettings
         {
-            SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
-
-            SupportedEncodings.Add(Encoding.UTF8);
-            SupportedEncodings.Add(Encoding.Unicode);
-
-            _jsonSerializerSettings = new JsonSerializerSettings
+            ContractResolver = new DefaultContractResolver
             {
-                ContractResolver = new DefaultContractResolver
-                {
-                    NamingStrategy = new DefaultNamingStrategy()
-                }
-            };
-        }
-
-        protected override bool CanWriteType(Type type) =>
-            typeof(Discover).IsAssignableFrom(type) || typeof(LineupStatus).IsAssignableFrom(type) ||
-            typeof(IEnumerable<LineupItem>).IsAssignableFrom(type);
-
-        public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
-            // ReSharper disable once PossibleNullReferenceException
-            context.HttpContext.Response.WriteAsync(
-                JsonConvert.SerializeObject(context.Object, _jsonSerializerSettings));
+                NamingStrategy = new DefaultNamingStrategy()
+            }
+        };
     }
-}
+
+    protected override bool CanWriteType(Type type) =>
+        typeof(Discover).IsAssignableFrom(type) || typeof(LineupStatus).IsAssignableFrom(type) ||
+        typeof(IEnumerable<LineupItem>).IsAssignableFrom(type);
+
+    public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) =>
+        // ReSharper disable once PossibleNullReferenceException
+        context.HttpContext.Response.WriteAsync(
+            JsonConvert.SerializeObject(context.Object, _jsonSerializerSettings));
+}
\ No newline at end of file
diff --git a/ErsatzTV/GlobalUsings.cs b/ErsatzTV/GlobalUsings.cs
new file mode 100644
index 000000000..9d0867420
--- /dev/null
+++ b/ErsatzTV/GlobalUsings.cs
@@ -0,0 +1,4 @@
+global using LanguageExt;
+global using static LanguageExt.Prelude;
+global using Unit = LanguageExt.Unit;
+global using Array = System.Array;
\ No newline at end of file
diff --git a/ErsatzTV/Pages/Artist.razor b/ErsatzTV/Pages/Artist.razor
index bac9871eb..f294d1399 100644
--- a/ErsatzTV/Pages/Artist.razor
+++ b/ErsatzTV/Pages/Artist.razor
@@ -1,16 +1,10 @@
 @page "/media/music/artists/{ArtistId:int}"
-@using ErsatzTV.Application.Artists
-@using ErsatzTV.Application.Artists.Queries
-@using ErsatzTV.Application.MediaCards
-@using ErsatzTV.Application.MediaCards.Queries
-@using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.ProgramSchedules
-@using ErsatzTV.Application.ProgramSchedules.Commands
-@using System.Globalization
-@using System.Threading
 @using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Artists
+@using ErsatzTV.Application.MediaCards
+@using ErsatzTV.Application.MediaCollections
+@using ErsatzTV.Application.ProgramSchedules
+@using System.Globalization
 @implements IDisposable
 @inject IMediator _mediator
 @inject IDialogService _dialog
diff --git a/ErsatzTV/Pages/ArtistList.razor b/ErsatzTV/Pages/ArtistList.razor
index f0ddc7720..24c1235fa 100644
--- a/ErsatzTV/Pages/ArtistList.razor
+++ b/ErsatzTV/Pages/ArtistList.razor
@@ -1,13 +1,10 @@
 @page "/media/music/artists"
 @page "/media/music/artists/page/{PageNumber:int}"
 @using LanguageExt.UnsafeValueAccess
-@using Microsoft.AspNetCore.WebUtilities
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Search
 @inherits MultiSelectBase<MusicVideoList>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/ChannelEditor.razor b/ErsatzTV/Pages/ChannelEditor.razor
index 769255ef2..9242d10f5 100644
--- a/ErsatzTV/Pages/ChannelEditor.razor
+++ b/ErsatzTV/Pages/ChannelEditor.razor
@@ -2,18 +2,13 @@
 @page "/channels/add"
 @using static LanguageExt.Prelude
 @using ErsatzTV.Application.FFmpegProfiles
-@using ErsatzTV.Application.FFmpegProfiles.Queries
-@using ErsatzTV.Application.Images.Commands
-@using ErsatzTV.Application.MediaItems.Queries
-@using System.Globalization
-@using System.Threading
-@using ErsatzTV.Application.Channels
-@using ErsatzTV.Application.Channels.Queries
 @using ErsatzTV.Application.Filler
-@using ErsatzTV.Application.Filler.Queries
+@using ErsatzTV.Application.Images
+@using ErsatzTV.Application.MediaItems
 @using ErsatzTV.Application.Watermarks
-@using ErsatzTV.Application.Watermarks.Queries
+@using System.Globalization
 @using ErsatzTV.Core.Domain.Filler
+@using ErsatzTV.Application.Channels
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<ChannelEditor> _logger
diff --git a/ErsatzTV/Pages/Channels.razor b/ErsatzTV/Pages/Channels.razor
index 5c8ba0c58..e29d242f2 100644
--- a/ErsatzTV/Pages/Channels.razor
+++ b/ErsatzTV/Pages/Channels.razor
@@ -1,13 +1,8 @@
 @page "/channels"
 @using ErsatzTV.Application.Channels
-@using ErsatzTV.Application.Channels.Commands
-@using ErsatzTV.Application.Channels.Queries
-@using ErsatzTV.Application.Configuration.Commands
-@using ErsatzTV.Application.Configuration.Queries
+@using ErsatzTV.Application.Configuration
 @using ErsatzTV.Application.FFmpegProfiles
-@using ErsatzTV.Application.FFmpegProfiles.Queries
 @using System.Globalization
-@using System.Threading
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/CollectionEditor.razor b/ErsatzTV/Pages/CollectionEditor.razor
index 90d0e88de..fca8699e7 100644
--- a/ErsatzTV/Pages/CollectionEditor.razor
+++ b/ErsatzTV/Pages/CollectionEditor.razor
@@ -1,9 +1,6 @@
 @page "/media/collections/{Id:int}/edit"
 @page "/media/collections/add"
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.MediaCollections.Queries
-@using System.Threading
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<CollectionEditor> _logger
diff --git a/ErsatzTV/Pages/CollectionItems.razor b/ErsatzTV/Pages/CollectionItems.razor
index 8dd63bf2b..1e89c4c00 100644
--- a/ErsatzTV/Pages/CollectionItems.razor
+++ b/ErsatzTV/Pages/CollectionItems.razor
@@ -1,7 +1,6 @@
 @page "/media/collections/{Id:int}"
 @using ErsatzTV.Application.MediaCards
-@using ErsatzTV.Application.MediaCards.Queries
-@using ErsatzTV.Application.MediaCollections.Commands
+@using ErsatzTV.Application.MediaCollections
 @inherits MultiSelectBase<CollectionItems>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/Collections.razor b/ErsatzTV/Pages/Collections.razor
index 80151273c..c000b0a63 100644
--- a/ErsatzTV/Pages/Collections.razor
+++ b/ErsatzTV/Pages/Collections.razor
@@ -1,11 +1,7 @@
 @page "/media/collections"
-@using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.MediaCollections.Queries
-@using ErsatzTV.Application.Configuration.Queries
-@using ErsatzTV.Application.Configuration.Commands
 @using ErsatzTV.Extensions
-@using System.Threading
+@using ErsatzTV.Application.MediaCollections
+@using ErsatzTV.Application.Configuration
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/EmbyLibrariesEditor.razor b/ErsatzTV/Pages/EmbyLibrariesEditor.razor
index 55af6498f..ad96f7935 100644
--- a/ErsatzTV/Pages/EmbyLibrariesEditor.razor
+++ b/ErsatzTV/Pages/EmbyLibrariesEditor.razor
@@ -1,10 +1,6 @@
 @page "/media/sources/emby/{Id:int}/libraries"
-@using Unit = LanguageExt.Unit
-@using ErsatzTV.Application.Emby.Commands
-@using ErsatzTV.Application.Emby.Queries
-@using ErsatzTV.Application.MediaSources
 @using ErsatzTV.Application.Emby
-@using System.Threading
+@using ErsatzTV.Application.MediaSources
 @implements IDisposable
 @inject IMediator _mediator
 @inject ChannelWriter<IEmbyBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/EmbyMediaSourceEditor.razor b/ErsatzTV/Pages/EmbyMediaSourceEditor.razor
index 32bcc296b..45df0a1e7 100644
--- a/ErsatzTV/Pages/EmbyMediaSourceEditor.razor
+++ b/ErsatzTV/Pages/EmbyMediaSourceEditor.razor
@@ -1,9 +1,6 @@
 @page "/media/sources/emby/edit"
-@using Unit = LanguageExt.Unit
 @using ErsatzTV.Core.Emby
-@using ErsatzTV.Application.Emby.Queries
-@using ErsatzTV.Application.Emby.Commands
-@using System.Threading
+@using ErsatzTV.Application.Emby
 @implements IDisposable
 @inject IMediator _mediator
 @inject NavigationManager _navigationManager
diff --git a/ErsatzTV/Pages/EmbyMediaSources.razor b/ErsatzTV/Pages/EmbyMediaSources.razor
index 7ce6610e3..83884687d 100644
--- a/ErsatzTV/Pages/EmbyMediaSources.razor
+++ b/ErsatzTV/Pages/EmbyMediaSources.razor
@@ -1,8 +1,6 @@
 @page "/media/sources/emby"
 @using ErsatzTV.Core.Interfaces.Emby
-@using ErsatzTV.Application.Emby.Commands
-@using ErsatzTV.Application.Emby.Queries
-@using System.Threading
+@using ErsatzTV.Application.Emby
 @implements IDisposable
 @inject IEmbySecretStore _embySecretStore
 @inject ChannelWriter<IEmbyBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/EmbyPathReplacementsEditor.razor b/ErsatzTV/Pages/EmbyPathReplacementsEditor.razor
index 32419c2bf..c40cf3d33 100644
--- a/ErsatzTV/Pages/EmbyPathReplacementsEditor.razor
+++ b/ErsatzTV/Pages/EmbyPathReplacementsEditor.razor
@@ -1,10 +1,6 @@
 @page "/media/sources/emby/{Id:int}/paths"
 @using ErsatzTV.Application.MediaSources
-@using ErsatzTV.Application.Emby.Queries
 @using ErsatzTV.Application.Emby
-@using ErsatzTV.Application.Emby.Commands
-@using Unit = LanguageExt.Unit
-@using System.Threading
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<ScheduleItemsEditor> _logger
diff --git a/ErsatzTV/Pages/EpisodeList.razor b/ErsatzTV/Pages/EpisodeList.razor
index f429481e4..5fd73f40b 100644
--- a/ErsatzTV/Pages/EpisodeList.razor
+++ b/ErsatzTV/Pages/EpisodeList.razor
@@ -1,13 +1,10 @@
 @page "/media/tv/episodes"
 @page "/media/tv/episodes/page/{PageNumber:int}"
 @using LanguageExt.UnsafeValueAccess
-@using Microsoft.AspNetCore.WebUtilities
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Search
 @inherits MultiSelectBase<EpisodeList>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/FFmpeg.razor b/ErsatzTV/Pages/FFmpeg.razor
index deff784bf..29caec0d3 100644
--- a/ErsatzTV/Pages/FFmpeg.razor
+++ b/ErsatzTV/Pages/FFmpeg.razor
@@ -1,8 +1,5 @@
 @page "/ffmpeg"
 @using ErsatzTV.Application.FFmpegProfiles
-@using ErsatzTV.Application.FFmpegProfiles.Commands
-@using ErsatzTV.Application.FFmpegProfiles.Queries
-@using System.Threading
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/FFmpegEditor.razor b/ErsatzTV/Pages/FFmpegEditor.razor
index 4a9bbdd78..097766b62 100644
--- a/ErsatzTV/Pages/FFmpegEditor.razor
+++ b/ErsatzTV/Pages/FFmpegEditor.razor
@@ -1,14 +1,9 @@
 @page "/ffmpeg/{Id:int}"
 @page "/ffmpeg/add"
-@using ErsatzTV.Application.Resolutions
-@using ErsatzTV.Application.Resolutions.Queries
-@using ErsatzTV.Application.FFmpegProfiles
-@using ErsatzTV.Application.FFmpegProfiles.Commands
-@using ErsatzTV.Application.FFmpegProfiles.Queries
-@using ErsatzTV.Core.FFmpeg
-@using Microsoft.AspNetCore.Components
 @using Microsoft.Extensions.Caching.Memory
-@using System.Threading
+@using ErsatzTV.Application.Resolutions
+@using ErsatzTV.Core.FFmpeg
+@using ErsatzTV.Application.FFmpegProfiles
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<FFmpegEditor> _logger
diff --git a/ErsatzTV/Pages/FillerPresetEditor.razor b/ErsatzTV/Pages/FillerPresetEditor.razor
index 24c71aca3..6aee6098b 100644
--- a/ErsatzTV/Pages/FillerPresetEditor.razor
+++ b/ErsatzTV/Pages/FillerPresetEditor.razor
@@ -1,15 +1,11 @@
 @page "/media/filler/presets/{Id:int}/edit"
 @page "/media/filler/presets/add"
-@using ErsatzTV.Application.Filler
-@using ErsatzTV.Application.Filler.Queries
-@using ErsatzTV.Application.Television.Queries
-@using ErsatzTV.Application.Artists.Queries
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Queries
 @using ErsatzTV.Application.MediaItems
+@using ErsatzTV.Application.Television
 @using ErsatzTV.Core.Domain.Filler
-@using Microsoft.AspNetCore.Components
-@using System.Threading
+@using ErsatzTV.Application.Artists
+@using ErsatzTV.Application.Filler
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<FillerPresetEditor> _logger
@@ -220,7 +216,7 @@
         _messageStore.Clear();
         if (_editContext.Validate())
         {
-            IRequest<Either<BaseError, LanguageExt.Unit>> request = IsEdit ? _model.ToEdit() : _model.ToUpdate();
+            IRequest<Either<BaseError, Unit>> request = IsEdit ? _model.ToEdit() : _model.ToUpdate();
 
             Seq<BaseError> errorMessage = await _mediator.Send(request, _cts.Token)
                 .Map(result => result.LeftToSeq());
diff --git a/ErsatzTV/Pages/FillerPresets.razor b/ErsatzTV/Pages/FillerPresets.razor
index 444771e4e..d8def4d03 100644
--- a/ErsatzTV/Pages/FillerPresets.razor
+++ b/ErsatzTV/Pages/FillerPresets.razor
@@ -1,11 +1,7 @@
 @page "/media/filler/presets"
 @using ErsatzTV.Application.Filler
-@using ErsatzTV.Application.Configuration.Queries
-@using ErsatzTV.Application.Configuration.Commands
-@using ErsatzTV.Application.Filler.Commands
-@using ErsatzTV.Application.Filler.Queries
 @using ErsatzTV.Core.Domain.Filler
-@using System.Threading
+@using ErsatzTV.Application.Configuration
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/FragmentNavigationBase.cs b/ErsatzTV/Pages/FragmentNavigationBase.cs
index 87471d006..93dfbd85b 100644
--- a/ErsatzTV/Pages/FragmentNavigationBase.cs
+++ b/ErsatzTV/Pages/FragmentNavigationBase.cs
@@ -1,53 +1,36 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Diagnostics.CodeAnalysis;
 using ErsatzTV.Extensions;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Routing;
 using Microsoft.JSInterop;
 
-namespace ErsatzTV.Pages
+namespace ErsatzTV.Pages;
+
+public class FragmentNavigationBase : ComponentBase, IDisposable
 {
-    public class FragmentNavigationBase : ComponentBase, IDisposable
-    {
-        private readonly CancellationTokenSource _cts = new();
+    private readonly CancellationTokenSource _cts = new();
 
-        protected CancellationToken CancellationToken => _cts.Token;
+    protected CancellationToken CancellationToken => _cts.Token;
         
-        [Inject]
-        private NavigationManager NavManager { get; set; }
+    [Inject]
+    private NavigationManager NavManager { get; set; }
 
-        [Inject]
-        private IJSRuntime JsRuntime { get; set; }
+    [Inject]
+    private IJSRuntime JsRuntime { get; set; }
 
-        public void Dispose()
-        {
-            NavManager.LocationChanged -= TryFragmentNavigation;
+    public void Dispose()
+    {
+        NavManager.LocationChanged -= TryFragmentNavigation;
 
-            _cts?.Cancel();
-            _cts?.Dispose();
-        }
+        _cts?.Cancel();
+        _cts?.Dispose();
+    }
 
-        protected override void OnInitialized() => NavManager.LocationChanged += TryFragmentNavigation;
+    protected override void OnInitialized() => NavManager.LocationChanged += TryFragmentNavigation;
 
-        protected override async Task OnAfterRenderAsync(bool firstRender)
-        {
-            if (firstRender)
-            {
-                try
-                {
-                    await NavManager.NavigateToFragmentAsync(JsRuntime);
-                }
-                catch (Exception)
-                {
-                    // ignored
-                }
-            }
-        }
-
-        [SuppressMessage("ReSharper", "VSTHRD100")]
-        private async void TryFragmentNavigation(object sender, LocationChangedEventArgs args)
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
         {
             try
             {
@@ -59,4 +42,17 @@ namespace ErsatzTV.Pages
             }
         }
     }
-}
+
+    [SuppressMessage("ReSharper", "VSTHRD100")]
+    private async void TryFragmentNavigation(object sender, LocationChangedEventArgs args)
+    {
+        try
+        {
+            await NavManager.NavigateToFragmentAsync(JsRuntime);
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Pages/Index.razor b/ErsatzTV/Pages/Index.razor
index f894352ba..7e8f76c9f 100644
--- a/ErsatzTV/Pages/Index.razor
+++ b/ErsatzTV/Pages/Index.razor
@@ -1,10 +1,9 @@
 @page "/"
 @using Microsoft.Extensions.Caching.Memory
 @using System.Reflection
-@using System.Threading
-@using ErsatzTV.Application.Health.Queries
-@using ErsatzTV.Core.Health
 @using ErsatzTV.Core.Interfaces.GitHub
+@using ErsatzTV.Core.Health
+@using ErsatzTV.Application.Health
 @implements IDisposable
 @inject IGitHubApiClient _gitHubApiClient
 @inject IMemoryCache _memoryCache
diff --git a/ErsatzTV/Pages/JellyfinLibrariesEditor.razor b/ErsatzTV/Pages/JellyfinLibrariesEditor.razor
index 00fab5ca7..15f393600 100644
--- a/ErsatzTV/Pages/JellyfinLibrariesEditor.razor
+++ b/ErsatzTV/Pages/JellyfinLibrariesEditor.razor
@@ -1,10 +1,6 @@
 @page "/media/sources/jellyfin/{Id:int}/libraries"
-@using Unit = LanguageExt.Unit
-@using ErsatzTV.Application.Jellyfin.Commands
-@using ErsatzTV.Application.Jellyfin.Queries
-@using ErsatzTV.Application.MediaSources
 @using ErsatzTV.Application.Jellyfin
-@using System.Threading
+@using ErsatzTV.Application.MediaSources
 @implements IDisposable
 @inject IMediator _mediator
 @inject ChannelWriter<IJellyfinBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/JellyfinMediaSourceEditor.razor b/ErsatzTV/Pages/JellyfinMediaSourceEditor.razor
index 0aa95d15d..d4004e1d9 100644
--- a/ErsatzTV/Pages/JellyfinMediaSourceEditor.razor
+++ b/ErsatzTV/Pages/JellyfinMediaSourceEditor.razor
@@ -1,9 +1,6 @@
 @page "/media/sources/jellyfin/edit"
-@using Unit = LanguageExt.Unit
 @using ErsatzTV.Core.Jellyfin
-@using ErsatzTV.Application.Jellyfin.Queries
-@using ErsatzTV.Application.Jellyfin.Commands
-@using System.Threading
+@using ErsatzTV.Application.Jellyfin
 @implements IDisposable
 @inject IMediator _mediator
 @inject NavigationManager _navigationManager
diff --git a/ErsatzTV/Pages/JellyfinMediaSources.razor b/ErsatzTV/Pages/JellyfinMediaSources.razor
index ee3d70dd7..b7527c7b6 100644
--- a/ErsatzTV/Pages/JellyfinMediaSources.razor
+++ b/ErsatzTV/Pages/JellyfinMediaSources.razor
@@ -1,8 +1,6 @@
 @page "/media/sources/jellyfin"
 @using ErsatzTV.Core.Interfaces.Jellyfin
-@using ErsatzTV.Application.Jellyfin.Commands
-@using ErsatzTV.Application.Jellyfin.Queries
-@using System.Threading
+@using ErsatzTV.Application.Jellyfin
 @implements IDisposable
 @inject IJellyfinSecretStore _jellyfinSecretStore
 @inject ChannelWriter<IJellyfinBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/JellyfinPathReplacementsEditor.razor b/ErsatzTV/Pages/JellyfinPathReplacementsEditor.razor
index e7964f5eb..1e892a29e 100644
--- a/ErsatzTV/Pages/JellyfinPathReplacementsEditor.razor
+++ b/ErsatzTV/Pages/JellyfinPathReplacementsEditor.razor
@@ -1,10 +1,6 @@
 @page "/media/sources/jellyfin/{Id:int}/paths"
 @using ErsatzTV.Application.MediaSources
-@using ErsatzTV.Application.Jellyfin.Queries
 @using ErsatzTV.Application.Jellyfin
-@using ErsatzTV.Application.Jellyfin.Commands
-@using Unit = LanguageExt.Unit
-@using System.Threading
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<ScheduleItemsEditor> _logger
diff --git a/ErsatzTV/Pages/Libraries.razor b/ErsatzTV/Pages/Libraries.razor
index 1b59b561e..65c6fcd09 100644
--- a/ErsatzTV/Pages/Libraries.razor
+++ b/ErsatzTV/Pages/Libraries.razor
@@ -1,15 +1,12 @@
 @page "/media/libraries"
 @using MediatR.Courier
 @using ErsatzTV.Application.Libraries
-@using ErsatzTV.Application.Libraries.Queries
-@using ErsatzTV.Application.MediaSources.Commands
-@using ErsatzTV.Application.Plex.Commands
+@using ErsatzTV.Application.MediaSources
+@using ErsatzTV.Application.Plex
 @using ErsatzTV.Core.Metadata
-@using System.Threading
+@using PlexLibraryViewModel = ErsatzTV.Application.Libraries.PlexLibraryViewModel
 @using ErsatzTV.Application.Jellyfin
-@using ErsatzTV.Application.Jellyfin.Commands
 @using ErsatzTV.Application.Emby
-@using ErsatzTV.Application.Emby.Commands
 @implements IDisposable
 @inject IMediator _mediator
 @inject IEntityLocker _locker
diff --git a/ErsatzTV/Pages/LocalLibraries.razor b/ErsatzTV/Pages/LocalLibraries.razor
index 8ab6c0ffb..308345fdd 100644
--- a/ErsatzTV/Pages/LocalLibraries.razor
+++ b/ErsatzTV/Pages/LocalLibraries.razor
@@ -1,8 +1,5 @@
 @page "/media/sources/local"
 @using ErsatzTV.Application.Libraries
-@using ErsatzTV.Application.Libraries.Commands
-@using ErsatzTV.Application.Libraries.Queries
-@using System.Threading
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/LocalLibraryEditor.razor b/ErsatzTV/Pages/LocalLibraryEditor.razor
index 5fb3b129f..71893bc6f 100644
--- a/ErsatzTV/Pages/LocalLibraryEditor.razor
+++ b/ErsatzTV/Pages/LocalLibraryEditor.razor
@@ -1,10 +1,6 @@
 @page "/media/sources/local/{Id:int}/edit"
 @page "/media/sources/local/add"
 @using ErsatzTV.Application.Libraries
-@using ErsatzTV.Application.Libraries.Commands
-@using ErsatzTV.Application.Libraries.Queries
-@using Unit = LanguageExt.Unit
-@using System.Threading
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IEntityLocker _locker
diff --git a/ErsatzTV/Pages/LocalLibraryPathEditor.razor b/ErsatzTV/Pages/LocalLibraryPathEditor.razor
index d650552f5..0932b7ac4 100644
--- a/ErsatzTV/Pages/LocalLibraryPathEditor.razor
+++ b/ErsatzTV/Pages/LocalLibraryPathEditor.razor
@@ -1,9 +1,6 @@
 @page "/media/libraries/local/{Id:int}/add"
 @using ErsatzTV.Application.Libraries
-@using ErsatzTV.Application.Libraries.Commands
-@using ErsatzTV.Application.Libraries.Queries
-@using ErsatzTV.Application.MediaSources.Commands
-@using System.Threading
+@using ErsatzTV.Application.MediaSources
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<LocalLibraryPathEditor> _logger
diff --git a/ErsatzTV/Pages/Logs.razor b/ErsatzTV/Pages/Logs.razor
index 097a9e3ce..b03cb3304 100644
--- a/ErsatzTV/Pages/Logs.razor
+++ b/ErsatzTV/Pages/Logs.razor
@@ -1,9 +1,6 @@
 @page "/system/logs"
 @using ErsatzTV.Application.Logs
-@using ErsatzTV.Application.Logs.Queries
-@using ErsatzTV.Application.Configuration.Queries
-@using ErsatzTV.Application.Configuration.Commands
-@using System.Threading
+@using ErsatzTV.Application.Configuration
 @implements IDisposable
 @inject IMediator _mediator
 
diff --git a/ErsatzTV/Pages/Movie.razor b/ErsatzTV/Pages/Movie.razor
index 809558f3a..e0b1824e1 100644
--- a/ErsatzTV/Pages/Movie.razor
+++ b/ErsatzTV/Pages/Movie.razor
@@ -1,12 +1,9 @@
 @page "/media/movies/{MovieId:int}"
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.Movies
-@using ErsatzTV.Application.Movies.Queries
 @using System.Globalization
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Extensions
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject IDialogService _dialog
diff --git a/ErsatzTV/Pages/MovieList.razor b/ErsatzTV/Pages/MovieList.razor
index 8cf8bbcb2..3c09cc268 100644
--- a/ErsatzTV/Pages/MovieList.razor
+++ b/ErsatzTV/Pages/MovieList.razor
@@ -1,12 +1,10 @@
 @page "/media/movies"
 @page "/media/movies/page/{PageNumber:int}"
 @using LanguageExt.UnsafeValueAccess
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Search
 @inherits MultiSelectBase<MovieList>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/MultiCollectionEditor.razor b/ErsatzTV/Pages/MultiCollectionEditor.razor
index c2ed556da..0f16f281a 100644
--- a/ErsatzTV/Pages/MultiCollectionEditor.razor
+++ b/ErsatzTV/Pages/MultiCollectionEditor.razor
@@ -1,9 +1,6 @@
 @page "/media/multi-collections/{Id:int}/edit"
 @page "/media/multi-collections/add"
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.MediaCollections.Queries
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject NavigationManager _navigationManager
diff --git a/ErsatzTV/Pages/MultiSelectBase.cs b/ErsatzTV/Pages/MultiSelectBase.cs
index 6f3c007c5..d5540b2cf 100644
--- a/ErsatzTV/Pages/MultiSelectBase.cs
+++ b/ErsatzTV/Pages/MultiSelectBase.cs
@@ -1,185 +1,174 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using ErsatzTV.Application.MediaCollections;
-using ErsatzTV.Application.MediaCollections.Commands;
 using ErsatzTV.Core;
 using ErsatzTV.Shared;
-using LanguageExt;
 using LanguageExt.UnsafeValueAccess;
 using MediatR;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
-using Microsoft.Extensions.Logging;
 using MudBlazor;
-using static LanguageExt.Prelude;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Pages
+namespace ErsatzTV.Pages;
+
+public class MultiSelectBase<T> : FragmentNavigationBase
 {
-    public class MultiSelectBase<T> : FragmentNavigationBase
+    private readonly System.Collections.Generic.HashSet<MediaCardViewModel> _selectedItems;
+    private Option<MediaCardViewModel> _recentlySelected;
+
+    public MultiSelectBase()
     {
-        private readonly System.Collections.Generic.HashSet<MediaCardViewModel> _selectedItems;
-        private Option<MediaCardViewModel> _recentlySelected;
+        _recentlySelected = None;
+        _selectedItems = new System.Collections.Generic.HashSet<MediaCardViewModel>();
+    }
 
-        public MultiSelectBase()
+    [Inject]
+    protected IDialogService Dialog { get; set; }
+
+    [Inject]
+    protected ISnackbar Snackbar { get; set; }
+
+    [Inject]
+    protected ILogger<T> Logger { get; set; }
+
+    [Inject]
+    protected IMediator Mediator { get; set; }
+
+    protected System.Collections.Generic.HashSet<MediaCardViewModel> SelectedItems => _selectedItems;
+
+    protected bool IsSelected(MediaCardViewModel card) =>
+        _selectedItems.Contains(card);
+
+    protected bool IsSelectMode() =>
+        _selectedItems.Any();
+
+    protected string SelectionLabel() =>
+        $"{_selectedItems.Count} {(_selectedItems.Count == 1 ? "Item" : "Items")} Selected";
+
+    protected void ClearSelection()
+    {
+        _selectedItems.Clear();
+        _recentlySelected = None;
+    }
+
+    protected virtual Task RefreshData() => Task.CompletedTask;
+
+    protected void SelectClicked(
+        Func<List<MediaCardViewModel>> getSortedItems,
+        MediaCardViewModel card,
+        MouseEventArgs e)
+    {
+        if (_selectedItems.Contains(card))
         {
-            _recentlySelected = None;
-            _selectedItems = new System.Collections.Generic.HashSet<MediaCardViewModel>();
+            _selectedItems.Remove(card);
         }
-
-        [Inject]
-        protected IDialogService Dialog { get; set; }
-
-        [Inject]
-        protected ISnackbar Snackbar { get; set; }
-
-        [Inject]
-        protected ILogger<T> Logger { get; set; }
-
-        [Inject]
-        protected IMediator Mediator { get; set; }
-
-        protected System.Collections.Generic.HashSet<MediaCardViewModel> SelectedItems => _selectedItems;
-
-        protected bool IsSelected(MediaCardViewModel card) =>
-            _selectedItems.Contains(card);
-
-        protected bool IsSelectMode() =>
-            _selectedItems.Any();
-
-        protected string SelectionLabel() =>
-            $"{_selectedItems.Count} {(_selectedItems.Count == 1 ? "Item" : "Items")} Selected";
-
-        protected void ClearSelection()
+        else
         {
-            _selectedItems.Clear();
-            _recentlySelected = None;
-        }
-
-        protected virtual Task RefreshData() => Task.CompletedTask;
-
-        protected void SelectClicked(
-            Func<List<MediaCardViewModel>> getSortedItems,
-            MediaCardViewModel card,
-            MouseEventArgs e)
-        {
-            if (_selectedItems.Contains(card))
+            if (e.ShiftKey && _recentlySelected.IsSome)
             {
-                _selectedItems.Remove(card);
-            }
-            else
-            {
-                if (e.ShiftKey && _recentlySelected.IsSome)
+                List<MediaCardViewModel> sorted = getSortedItems();
+
+                int start = sorted.IndexOf(_recentlySelected.ValueUnsafe());
+                int finish = sorted.IndexOf(card);
+                if (start > finish)
                 {
-                    List<MediaCardViewModel> sorted = getSortedItems();
-
-                    int start = sorted.IndexOf(_recentlySelected.ValueUnsafe());
-                    int finish = sorted.IndexOf(card);
-                    if (start > finish)
-                    {
-                        (start, finish) = (finish, start);
-                    }
-
-                    for (int i = start; i < finish; i++)
-                    {
-                        _selectedItems.Add(sorted[i]);
-                    }
+                    (start, finish) = (finish, start);
                 }
 
-                _recentlySelected = card;
-                _selectedItems.Add(card);
+                for (int i = start; i < finish; i++)
+                {
+                    _selectedItems.Add(sorted[i]);
+                }
             }
-        }
 
-        protected Task AddSelectionToCollection() => AddItemsToCollection(
-            _selectedItems.OfType<MovieCardViewModel>().Map(m => m.MovieId).ToList(),
-            _selectedItems.OfType<TelevisionShowCardViewModel>().Map(s => s.TelevisionShowId).ToList(),
-            _selectedItems.OfType<TelevisionSeasonCardViewModel>().Map(s => s.TelevisionSeasonId).ToList(),
-            _selectedItems.OfType<TelevisionEpisodeCardViewModel>().Map(e => e.EpisodeId).ToList(),
-            _selectedItems.OfType<ArtistCardViewModel>().Map(a => a.ArtistId).ToList(),
-            _selectedItems.OfType<MusicVideoCardViewModel>().Map(mv => mv.MusicVideoId).ToList(),
-            _selectedItems.OfType<OtherVideoCardViewModel>().Map(ov => ov.OtherVideoId).ToList(),
-            _selectedItems.OfType<SongCardViewModel>().Map(s => s.SongId).ToList());
-
-        protected async Task AddItemsToCollection(
-            List<int> movieIds,
-            List<int> showIds,
-            List<int> seasonIds,
-            List<int> episodeIds,
-            List<int> artistIds,
-            List<int> musicVideoIds,
-            List<int> otherVideoIds,
-            List<int> songIds,
-            string entityName = "selected items")
-        {
-            int count = movieIds.Count + showIds.Count + seasonIds.Count + episodeIds.Count + artistIds.Count +
-                        musicVideoIds.Count + otherVideoIds.Count + songIds.Count;
-
-            var parameters = new DialogParameters
-                { { "EntityType", count.ToString() }, { "EntityName", entityName } };
-            var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };
-
-            IDialogReference dialog = Dialog.Show<AddToCollectionDialog>("Add To Collection", parameters, options);
-            DialogResult result = await dialog.Result;
-            if (!result.Cancelled && result.Data is MediaCollectionViewModel collection)
-            {
-                var request = new AddItemsToCollection(
-                    collection.Id,
-                    movieIds,
-                    showIds,
-                    seasonIds,
-                    episodeIds,
-                    artistIds,
-                    musicVideoIds,
-                    otherVideoIds,
-                    songIds);
-
-                Either<BaseError, Unit> addResult = await Mediator.Send(request, CancellationToken);
-                addResult.Match(
-                    Left: error =>
-                    {
-                        Snackbar.Add($"Unexpected error adding items to collection: {error.Value}");
-                        Logger.LogError("Unexpected error adding items to collection: {Error}", error.Value);
-                    },
-                    Right: _ =>
-                    {
-                        Snackbar.Add(
-                            $"Added {count} items to collection {collection.Name}",
-                            Severity.Success);
-                        ClearSelection();
-                    });
-            }
-        }
-
-        protected async Task RemoveSelectionFromCollection(int collectionId)
-        {
-            var parameters = new DialogParameters
-                { { "EntityType", _selectedItems.Count.ToString() }, { "EntityName", "selected items" } };
-            var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };
-
-            IDialogReference dialog = Dialog.Show<RemoveFromCollectionDialog>(
-                "Remove From Collection",
-                parameters,
-                options);
-            DialogResult result = await dialog.Result;
-            if (!result.Cancelled)
-            {
-                var itemIds = _selectedItems.Map(vm => vm.MediaItemId).ToList();
-
-                await Mediator.Send(
-                    new RemoveItemsFromCollection(collectionId)
-                    {
-                        MediaItemIds = itemIds
-                    },
-                    CancellationToken);
-
-                await RefreshData();
-                ClearSelection();
-            }
+            _recentlySelected = card;
+            _selectedItems.Add(card);
         }
     }
-}
+
+    protected Task AddSelectionToCollection() => AddItemsToCollection(
+        _selectedItems.OfType<MovieCardViewModel>().Map(m => m.MovieId).ToList(),
+        _selectedItems.OfType<TelevisionShowCardViewModel>().Map(s => s.TelevisionShowId).ToList(),
+        _selectedItems.OfType<TelevisionSeasonCardViewModel>().Map(s => s.TelevisionSeasonId).ToList(),
+        _selectedItems.OfType<TelevisionEpisodeCardViewModel>().Map(e => e.EpisodeId).ToList(),
+        _selectedItems.OfType<ArtistCardViewModel>().Map(a => a.ArtistId).ToList(),
+        _selectedItems.OfType<MusicVideoCardViewModel>().Map(mv => mv.MusicVideoId).ToList(),
+        _selectedItems.OfType<OtherVideoCardViewModel>().Map(ov => ov.OtherVideoId).ToList(),
+        _selectedItems.OfType<SongCardViewModel>().Map(s => s.SongId).ToList());
+
+    protected async Task AddItemsToCollection(
+        List<int> movieIds,
+        List<int> showIds,
+        List<int> seasonIds,
+        List<int> episodeIds,
+        List<int> artistIds,
+        List<int> musicVideoIds,
+        List<int> otherVideoIds,
+        List<int> songIds,
+        string entityName = "selected items")
+    {
+        int count = movieIds.Count + showIds.Count + seasonIds.Count + episodeIds.Count + artistIds.Count +
+                    musicVideoIds.Count + otherVideoIds.Count + songIds.Count;
+
+        var parameters = new DialogParameters
+            { { "EntityType", count.ToString() }, { "EntityName", entityName } };
+        var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };
+
+        IDialogReference dialog = Dialog.Show<AddToCollectionDialog>("Add To Collection", parameters, options);
+        DialogResult result = await dialog.Result;
+        if (!result.Cancelled && result.Data is MediaCollectionViewModel collection)
+        {
+            var request = new AddItemsToCollection(
+                collection.Id,
+                movieIds,
+                showIds,
+                seasonIds,
+                episodeIds,
+                artistIds,
+                musicVideoIds,
+                otherVideoIds,
+                songIds);
+
+            Either<BaseError, Unit> addResult = await Mediator.Send(request, CancellationToken);
+            addResult.Match(
+                Left: error =>
+                {
+                    Snackbar.Add($"Unexpected error adding items to collection: {error.Value}");
+                    Logger.LogError("Unexpected error adding items to collection: {Error}", error.Value);
+                },
+                Right: _ =>
+                {
+                    Snackbar.Add(
+                        $"Added {count} items to collection {collection.Name}",
+                        Severity.Success);
+                    ClearSelection();
+                });
+        }
+    }
+
+    protected async Task RemoveSelectionFromCollection(int collectionId)
+    {
+        var parameters = new DialogParameters
+            { { "EntityType", _selectedItems.Count.ToString() }, { "EntityName", "selected items" } };
+        var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };
+
+        IDialogReference dialog = Dialog.Show<RemoveFromCollectionDialog>(
+            "Remove From Collection",
+            parameters,
+            options);
+        DialogResult result = await dialog.Result;
+        if (!result.Cancelled)
+        {
+            var itemIds = _selectedItems.Map(vm => vm.MediaItemId).ToList();
+
+            await Mediator.Send(
+                new RemoveItemsFromCollection(collectionId)
+                {
+                    MediaItemIds = itemIds
+                },
+                CancellationToken);
+
+            await RefreshData();
+            ClearSelection();
+        }
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Pages/MusicVideoList.razor b/ErsatzTV/Pages/MusicVideoList.razor
index b53b245bb..c5ee079b6 100644
--- a/ErsatzTV/Pages/MusicVideoList.razor
+++ b/ErsatzTV/Pages/MusicVideoList.razor
@@ -1,13 +1,10 @@
 @page "/media/music/videos"
 @page "/media/music/videos/page/{PageNumber:int}"
 @using LanguageExt.UnsafeValueAccess
-@using Microsoft.AspNetCore.WebUtilities
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Search
 @inherits MultiSelectBase<MusicVideoList>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/OtherVideoList.razor b/ErsatzTV/Pages/OtherVideoList.razor
index 5e2f391dd..def2b30f3 100644
--- a/ErsatzTV/Pages/OtherVideoList.razor
+++ b/ErsatzTV/Pages/OtherVideoList.razor
@@ -1,12 +1,10 @@
 @page "/media/other/videos"
 @page "/media/other/videos/page/{PageNumber:int}"
 @using LanguageExt.UnsafeValueAccess
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Search
 @inherits MultiSelectBase<OtherVideoList>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/PlayoutEditor.razor b/ErsatzTV/Pages/PlayoutEditor.razor
index 099e6fffa..bb39e84a3 100644
--- a/ErsatzTV/Pages/PlayoutEditor.razor
+++ b/ErsatzTV/Pages/PlayoutEditor.razor
@@ -1,9 +1,6 @@
 @page "/playouts/add"
 @using ErsatzTV.Application.Channels
-@using ErsatzTV.Application.Channels.Queries
 @using ErsatzTV.Application.ProgramSchedules
-@using ErsatzTV.Application.ProgramSchedules.Queries
-@using System.Threading
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<PlayoutEditor> _logger
diff --git a/ErsatzTV/Pages/Playouts.razor b/ErsatzTV/Pages/Playouts.razor
index 5595848d5..226fae8cd 100644
--- a/ErsatzTV/Pages/Playouts.razor
+++ b/ErsatzTV/Pages/Playouts.razor
@@ -1,10 +1,6 @@
 @page "/playouts"
 @using ErsatzTV.Application.Playouts
-@using ErsatzTV.Application.Playouts.Commands
-@using ErsatzTV.Application.Playouts.Queries
-@using ErsatzTV.Application.Configuration.Commands
-@using ErsatzTV.Application.Configuration.Queries
-@using System.Threading
+@using ErsatzTV.Application.Configuration
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/PlexLibrariesEditor.razor b/ErsatzTV/Pages/PlexLibrariesEditor.razor
index e36bc8c9d..32cbe1748 100644
--- a/ErsatzTV/Pages/PlexLibrariesEditor.razor
+++ b/ErsatzTV/Pages/PlexLibrariesEditor.razor
@@ -1,10 +1,6 @@
 @page "/media/sources/plex/{Id:int}/libraries"
-@using Unit = LanguageExt.Unit
-@using ErsatzTV.Application.Plex.Commands
-@using ErsatzTV.Application.Plex.Queries
-@using ErsatzTV.Application.MediaSources
 @using ErsatzTV.Application.Plex
-@using System.Threading
+@using ErsatzTV.Application.MediaSources
 @implements IDisposable
 @inject IMediator _mediator
 @inject ChannelWriter<IPlexBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/PlexMediaSources.razor b/ErsatzTV/Pages/PlexMediaSources.razor
index a5756c98e..2ebf30c38 100644
--- a/ErsatzTV/Pages/PlexMediaSources.razor
+++ b/ErsatzTV/Pages/PlexMediaSources.razor
@@ -1,9 +1,6 @@
 @page "/media/sources/plex"
 @using ErsatzTV.Core.Interfaces.Plex
 @using ErsatzTV.Application.Plex
-@using ErsatzTV.Application.Plex.Commands
-@using ErsatzTV.Application.Plex.Queries
-@using System.Threading
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/PlexPathReplacementsEditor.razor b/ErsatzTV/Pages/PlexPathReplacementsEditor.razor
index e73e57832..5f5e59d53 100644
--- a/ErsatzTV/Pages/PlexPathReplacementsEditor.razor
+++ b/ErsatzTV/Pages/PlexPathReplacementsEditor.razor
@@ -1,10 +1,6 @@
 @page "/media/sources/plex/{Id:int}/paths"
 @using ErsatzTV.Application.MediaSources
 @using ErsatzTV.Application.Plex
-@using ErsatzTV.Application.Plex.Commands
-@using ErsatzTV.Application.Plex.Queries
-@using Unit = LanguageExt.Unit
-@using System.Threading
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<ScheduleItemsEditor> _logger
diff --git a/ErsatzTV/Pages/ScheduleEditor.razor b/ErsatzTV/Pages/ScheduleEditor.razor
index 9fd9f04bf..dee0b0733 100644
--- a/ErsatzTV/Pages/ScheduleEditor.razor
+++ b/ErsatzTV/Pages/ScheduleEditor.razor
@@ -1,8 +1,6 @@
 @page "/schedules/{Id:int}"
 @page "/schedules/add"
 @using ErsatzTV.Application.ProgramSchedules
-@using ErsatzTV.Application.ProgramSchedules.Queries
-@using System.Threading
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<ScheduleEditor> _logger
diff --git a/ErsatzTV/Pages/ScheduleItemsEditor.razor b/ErsatzTV/Pages/ScheduleItemsEditor.razor
index 09d550dbe..77009a1fe 100644
--- a/ErsatzTV/Pages/ScheduleItemsEditor.razor
+++ b/ErsatzTV/Pages/ScheduleItemsEditor.razor
@@ -1,16 +1,11 @@
 @page "/schedules/{Id:int}/items"
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Queries
 @using ErsatzTV.Application.MediaItems
 @using ErsatzTV.Application.ProgramSchedules
-@using ErsatzTV.Application.ProgramSchedules.Commands
-@using ErsatzTV.Application.ProgramSchedules.Queries
-@using ErsatzTV.Application.Television.Queries
-@using ErsatzTV.Application.Artists.Queries
+@using ErsatzTV.Application.Television
 @using ErsatzTV.Application.Filler
-@using ErsatzTV.Application.Filler.Queries
 @using ErsatzTV.Core.Domain.Filler
-@using System.Threading
+@using ErsatzTV.Application.Artists
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<ScheduleItemsEditor> _logger
diff --git a/ErsatzTV/Pages/Schedules.razor b/ErsatzTV/Pages/Schedules.razor
index a37518174..ffe87cd25 100644
--- a/ErsatzTV/Pages/Schedules.razor
+++ b/ErsatzTV/Pages/Schedules.razor
@@ -1,11 +1,7 @@
 @page "/schedules"
 @using ErsatzTV.Application.ProgramSchedules
-@using ErsatzTV.Application.ProgramSchedules.Commands
-@using ErsatzTV.Application.ProgramSchedules.Queries
-@using ErsatzTV.Application.Configuration.Queries
-@using ErsatzTV.Application.Configuration.Commands
+@using ErsatzTV.Application.Configuration
 @using NaturalSort.Extension
-@using System.Threading
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/Search.razor b/ErsatzTV/Pages/Search.razor
index ebb7dad93..842afb36a 100644
--- a/ErsatzTV/Pages/Search.razor
+++ b/ErsatzTV/Pages/Search.razor
@@ -1,11 +1,8 @@
 @page "/search"
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
 @using ErsatzTV.Application.Search
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
 @inherits MultiSelectBase<Search>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/Settings.razor b/ErsatzTV/Pages/Settings.razor
index 32217c3f9..f66680dd2 100644
--- a/ErsatzTV/Pages/Settings.razor
+++ b/ErsatzTV/Pages/Settings.razor
@@ -1,22 +1,12 @@
 @page "/settings"
 @using ErsatzTV.Application.FFmpegProfiles
-@using ErsatzTV.Application.FFmpegProfiles.Commands
-@using ErsatzTV.Application.FFmpegProfiles.Queries
-@using ErsatzTV.Application.HDHR.Commands
-@using ErsatzTV.Application.HDHR.Queries
-@using ErsatzTV.Application.MediaItems.Queries
-@using System.Globalization
-@using ErsatzTV.Application.Configuration.Queries
-@using Unit = LanguageExt.Unit
-@using ErsatzTV.Application.Configuration.Commands
 @using ErsatzTV.Application.Filler
-@using ErsatzTV.Application.Filler.Queries
+@using ErsatzTV.Application.HDHR
+@using ErsatzTV.Application.MediaItems
 @using ErsatzTV.Application.Watermarks
-@using ErsatzTV.Application.Watermarks.Queries
+@using System.Globalization
 @using ErsatzTV.Core.Domain.Filler
-@using ErsatzTV.Core.FFmpeg
-@using Microsoft.AspNetCore.Components
-@using System.Threading
+@using ErsatzTV.Application.Configuration
 @implements IDisposable
 @inject IMediator _mediator
 @inject ISnackbar _snackbar
diff --git a/ErsatzTV/Pages/SongList.razor b/ErsatzTV/Pages/SongList.razor
index 694f62907..076f341fa 100644
--- a/ErsatzTV/Pages/SongList.razor
+++ b/ErsatzTV/Pages/SongList.razor
@@ -1,12 +1,10 @@
 @page "/media/music/songs"
 @page "/media/music/songs/page/{PageNumber:int}"
 @using LanguageExt.UnsafeValueAccess
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Search
 @inherits MultiSelectBase<SongList>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/TelevisionEpisodeList.razor b/ErsatzTV/Pages/TelevisionEpisodeList.razor
index 8c74ac286..f7f640fcf 100644
--- a/ErsatzTV/Pages/TelevisionEpisodeList.razor
+++ b/ErsatzTV/Pages/TelevisionEpisodeList.razor
@@ -1,15 +1,9 @@
 @page "/media/tv/seasons/{SeasonId:int}"
 @using ErsatzTV.Extensions
 @using ErsatzTV.Application.Television
-@using ErsatzTV.Application.Television.Queries
 @using ErsatzTV.Application.MediaCards
-@using ErsatzTV.Application.MediaCards.Queries
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
 @using ErsatzTV.Application.ProgramSchedules
-@using ErsatzTV.Application.ProgramSchedules.Commands
-@using Unit = LanguageExt.Unit
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject ILogger<TelevisionEpisodeList> _logger
diff --git a/ErsatzTV/Pages/TelevisionSeasonList.razor b/ErsatzTV/Pages/TelevisionSeasonList.razor
index 4903f3b79..d15eb3b85 100644
--- a/ErsatzTV/Pages/TelevisionSeasonList.razor
+++ b/ErsatzTV/Pages/TelevisionSeasonList.razor
@@ -1,16 +1,10 @@
 @page "/media/tv/shows/{ShowId:int}"
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.Television
-@using ErsatzTV.Application.Television.Queries
 @using System.Globalization
 @using ErsatzTV.Application.MediaCards
-@using ErsatzTV.Application.MediaCards.Queries
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
 @using ErsatzTV.Application.ProgramSchedules
-@using ErsatzTV.Application.ProgramSchedules.Commands
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject ILogger<TelevisionSeasonList> _logger
diff --git a/ErsatzTV/Pages/TelevisionSeasonSearchResults.razor b/ErsatzTV/Pages/TelevisionSeasonSearchResults.razor
index 99d8f06a2..b0e2eeaff 100644
--- a/ErsatzTV/Pages/TelevisionSeasonSearchResults.razor
+++ b/ErsatzTV/Pages/TelevisionSeasonSearchResults.razor
@@ -1,12 +1,10 @@
 @page "/media/tv/seasons"
 @page "/media/tv/seasons/page/{PageNumber:int}"
 @using LanguageExt.UnsafeValueAccess
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Search
 @inherits MultiSelectBase<TelevisionShowList>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/TelevisionShowList.razor b/ErsatzTV/Pages/TelevisionShowList.razor
index 87b97c326..3046ccdfe 100644
--- a/ErsatzTV/Pages/TelevisionShowList.razor
+++ b/ErsatzTV/Pages/TelevisionShowList.razor
@@ -1,12 +1,10 @@
 @page "/media/tv/shows"
 @page "/media/tv/shows/page/{PageNumber:int}"
 @using LanguageExt.UnsafeValueAccess
+@using ErsatzTV.Extensions
 @using ErsatzTV.Application.MediaCards
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.Search.Queries
-@using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
+@using ErsatzTV.Application.Search
 @inherits MultiSelectBase<TelevisionShowList>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/TraktLists.razor b/ErsatzTV/Pages/TraktLists.razor
index c52d7c67b..d3bb92dd6 100644
--- a/ErsatzTV/Pages/TraktLists.razor
+++ b/ErsatzTV/Pages/TraktLists.razor
@@ -1,10 +1,6 @@
 @page "/media/trakt/lists"
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Queries
-@using ErsatzTV.Application.Configuration.Queries
-@using ErsatzTV.Application.Configuration.Commands
-@using ErsatzTV.Application.MediaCollections.Commands
-@using System.Threading
+@using ErsatzTV.Application.Configuration
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Pages/Trash.razor b/ErsatzTV/Pages/Trash.razor
index a0eb6a64e..b7b6b4668 100644
--- a/ErsatzTV/Pages/Trash.razor
+++ b/ErsatzTV/Pages/Trash.razor
@@ -1,9 +1,8 @@
 @page "/media/trash"
-@using ErsatzTV.Application.MediaCards
-@using ErsatzTV.Application.Search.Queries
 @using ErsatzTV.Extensions
-@using Unit = LanguageExt.Unit
-@using ErsatzTV.Application.Maintenance.Commands
+@using ErsatzTV.Application.MediaCards
+@using ErsatzTV.Application.Search
+@using ErsatzTV.Application.Maintenance
 @inherits MultiSelectBase<Search>
 @inject NavigationManager _navigationManager
 @inject ChannelWriter<IBackgroundServiceRequest> _channel
diff --git a/ErsatzTV/Pages/WatermarkEditor.razor b/ErsatzTV/Pages/WatermarkEditor.razor
index 793cb1b47..a4830bbf0 100644
--- a/ErsatzTV/Pages/WatermarkEditor.razor
+++ b/ErsatzTV/Pages/WatermarkEditor.razor
@@ -1,10 +1,8 @@
 @page "/watermarks/{Id:int}"
 @page "/watermarks/add"
-@using ErsatzTV.Application.Images.Commands
-@using ErsatzTV.Application.Watermarks
-@using ErsatzTV.Application.Watermarks.Queries
 @using ErsatzTV.FFmpeg.State
-@using System.Threading
+@using ErsatzTV.Application.Watermarks
+@using ErsatzTV.Application.Images
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<WatermarkEditor> _logger
diff --git a/ErsatzTV/Pages/Watermarks.razor b/ErsatzTV/Pages/Watermarks.razor
index 84f563bea..ff6a710b7 100644
--- a/ErsatzTV/Pages/Watermarks.razor
+++ b/ErsatzTV/Pages/Watermarks.razor
@@ -1,8 +1,5 @@
 @page "/watermarks"
 @using ErsatzTV.Application.Watermarks
-@using ErsatzTV.Application.Watermarks.Commands
-@using ErsatzTV.Application.Watermarks.Queries
-@using System.Threading
 @implements IDisposable
 @inject IDialogService _dialog
 @inject IMediator _mediator
diff --git a/ErsatzTV/Program.cs b/ErsatzTV/Program.cs
index 60278b88d..9587f8450 100644
--- a/ErsatzTV/Program.cs
+++ b/ErsatzTV/Program.cs
@@ -1,74 +1,67 @@
-using System;
-using System.IO;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Hosting;
 using Serilog;
 
-namespace ErsatzTV
+namespace ErsatzTV;
+
+public class Program
 {
-    public class Program
+    private static readonly string BasePath;
+
+    static Program()
     {
-        private static readonly string BasePath;
+        string executablePath = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
+        string executable = Path.GetFileNameWithoutExtension(executablePath);
 
-        static Program()
-        {
-            string executablePath = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
-            string executable = Path.GetFileNameWithoutExtension(executablePath);
+        IConfigurationBuilder builder = new ConfigurationBuilder();
 
-            IConfigurationBuilder builder = new ConfigurationBuilder();
+        BasePath = Path.GetDirectoryName(
+            "dotnet".Equals(executable, StringComparison.InvariantCultureIgnoreCase)
+                ? typeof(Program).Assembly.Location
+                : executablePath);
 
-            BasePath = Path.GetDirectoryName(
-                "dotnet".Equals(executable, StringComparison.InvariantCultureIgnoreCase)
-                    ? typeof(Program).Assembly.Location
-                    : executablePath);
-
-            Configuration = builder
-                .SetBasePath(BasePath)
-                .AddJsonFile("appsettings.json", false, true)
-                .AddJsonFile(
-                    $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json",
-                    true)
-                .AddEnvironmentVariables()
-                .Build();
-        }
-
-        private static IConfiguration Configuration { get; }
-
-        public static async Task<int> Main(string[] args)
-        {
-            Log.Logger = new LoggerConfiguration()
-                .ReadFrom.Configuration(Configuration)
-                .Enrich.FromLogContext()
-                .WriteTo.SQLite(FileSystemLayout.LogDatabasePath, retentionPeriod: TimeSpan.FromDays(1))
-                .WriteTo.File(FileSystemLayout.LogFilePath, rollingInterval: RollingInterval.Day)
-                .CreateLogger();
-
-            try
-            {
-                await CreateHostBuilder(args).Build().RunAsync();
-                return 0;
-            }
-            catch (Exception ex)
-            {
-                Log.Fatal(ex, "Host terminated unexpectedly");
-                return 1;
-            }
-            finally
-            {
-                Log.CloseAndFlush();
-            }
-        }
-
-        private static IHostBuilder CreateHostBuilder(string[] args) =>
-            Host.CreateDefaultBuilder(args)
-                .ConfigureWebHostDefaults(
-                    webBuilder => webBuilder.UseStartup<Startup>()
-                        .UseConfiguration(Configuration)
-                        .UseKestrel(options => options.AddServerHeader = false)
-                        .UseContentRoot(BasePath))
-                .UseSerilog();
+        Configuration = builder
+            .SetBasePath(BasePath)
+            .AddJsonFile("appsettings.json", false, true)
+            .AddJsonFile(
+                $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? "Production"}.json",
+                true)
+            .AddEnvironmentVariables()
+            .Build();
     }
-}
+
+    private static IConfiguration Configuration { get; }
+
+    public static async Task<int> Main(string[] args)
+    {
+        Log.Logger = new LoggerConfiguration()
+            .ReadFrom.Configuration(Configuration)
+            .Enrich.FromLogContext()
+            .WriteTo.SQLite(FileSystemLayout.LogDatabasePath, retentionPeriod: TimeSpan.FromDays(1))
+            .WriteTo.File(FileSystemLayout.LogFilePath, rollingInterval: RollingInterval.Day)
+            .CreateLogger();
+
+        try
+        {
+            await CreateHostBuilder(args).Build().RunAsync();
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            Log.Fatal(ex, "Host terminated unexpectedly");
+            return 1;
+        }
+        finally
+        {
+            Log.CloseAndFlush();
+        }
+    }
+
+    private static IHostBuilder CreateHostBuilder(string[] args) =>
+        Host.CreateDefaultBuilder(args)
+            .ConfigureWebHostDefaults(
+                webBuilder => webBuilder.UseStartup<Startup>()
+                    .UseConfiguration(Configuration)
+                    .UseKestrel(options => options.AddServerHeader = false)
+                    .UseContentRoot(BasePath))
+            .UseSerilog();
+}
\ No newline at end of file
diff --git a/ErsatzTV/Properties/Annotations.cs b/ErsatzTV/Properties/Annotations.cs
index 928c91c46..f65e6a7e4 100644
--- a/ErsatzTV/Properties/Annotations.cs
+++ b/ErsatzTV/Properties/Annotations.cs
@@ -20,7 +20,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE. */
 
-using System;
+
 
 // ReSharper disable InheritdocConsiderUsage
 
@@ -32,1429 +32,1428 @@ using System;
 // ReSharper disable MemberCanBeProtected.Global
 // ReSharper disable InconsistentNaming
 
-namespace ErsatzTV.Annotations
+namespace ErsatzTV.Annotations;
+
+/// <summary>
+///     Indicates that the value of the marked element could be <c>null</c> sometimes,
+///     so checking for <c>null</c> is required before its usage.
+/// </summary>
+/// <example>
+///     <code>
+/// [CanBeNull] object Test() => null;
+/// 
+/// void UseTest() {
+///   var p = Test();
+///   var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event |
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)]
+public sealed class CanBeNullAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that the value of the marked element can never be <c>null</c>.
+/// </summary>
+/// <example>
+///     <code>
+/// [NotNull] object Foo() {
+///   return null; // Warning: Possible 'null' assignment
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event |
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)]
+public sealed class NotNullAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task
+///     and Lazy classes to indicate that the value of a collection item, of the Task.Result property
+///     or of the Lazy.Value property can never be null.
+/// </summary>
+/// <example>
+///     <code>
+/// public void Foo([ItemNotNull]List&lt;string&gt; books)
+/// {
+///   foreach (var book in books) {
+///     if (book != null) // Warning: Expression is always true
+///      Console.WriteLine(book.ToUpper());
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field)]
+public sealed class ItemNotNullAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task
+///     and Lazy classes to indicate that the value of a collection item, of the Task.Result property
+///     or of the Lazy.Value property can be null.
+/// </summary>
+/// <example>
+///     <code>
+/// public void Foo([ItemCanBeNull]List&lt;string&gt; books)
+/// {
+///   foreach (var book in books)
+///   {
+///     // Warning: Possible 'System.NullReferenceException'
+///     Console.WriteLine(book.ToUpper());
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
+    AttributeTargets.Delegate | AttributeTargets.Field)]
+public sealed class ItemCanBeNullAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that the marked method builds string by the format pattern and (optional) arguments.
+///     The parameter, which contains the format string, should be given in constructor. The format string
+///     should be in <see cref="string.Format(IFormatProvider,string,object[])" />-like form.
+/// </summary>
+/// <example>
+///     <code>
+/// [StringFormatMethod("message")]
+/// void ShowError(string message, params object[] args) { /* do something */ }
+/// 
+/// void Foo() {
+///   ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Constructor | AttributeTargets.Method |
+    AttributeTargets.Property | AttributeTargets.Delegate)]
+public sealed class StringFormatMethodAttribute : Attribute
+{
+    /// <param name="formatParameterName">
+    ///     Specifies which parameter of an annotated method should be treated as the format string
+    /// </param>
+    public StringFormatMethodAttribute(
+        [NotNull]
+        string formatParameterName) => FormatParameterName = formatParameterName;
+
+    [NotNull]
+    public string FormatParameterName { get; }
+}
+
+/// <summary>
+///     Use this annotation to specify a type that contains static or const fields
+///     with values for the annotated property/field/parameter.
+///     The specified type will be used to improve completion suggestions.
+/// </summary>
+/// <example>
+///     <code>
+/// namespace TestNamespace
+/// {
+///   public class Constants
+///   {
+///     public static int INT_CONST = 1;
+///     public const string STRING_CONST = "1";
+///   }
+/// 
+///   public class Class1
+///   {
+///     [ValueProvider("TestNamespace.Constants")] public int myField;
+///     public void Foo([ValueProvider("TestNamespace.Constants")] string str) { }
+/// 
+///     public void Test()
+///     {
+///       Foo(/*try completion here*/);//
+///       myField = /*try completion here*/
+///     }
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field,
+    AllowMultiple = true)]
+public sealed class ValueProviderAttribute : Attribute
+{
+    public ValueProviderAttribute(
+        [NotNull]
+        string name) => Name = name;
+
+    [NotNull]
+    public string Name { get; }
+}
+
+/// <summary>
+///     Indicates that the integral value falls into the specified interval.
+///     It's allowed to specify multiple non-intersecting intervals.
+///     Values of interval boundaries are inclusive.
+/// </summary>
+/// <example>
+///     <code>
+/// void Foo([ValueRange(0, 100)] int value) {
+///   if (value == -1) { // Warning: Expression is always 'false'
+///     ...
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property |
+    AttributeTargets.Method | AttributeTargets.Delegate,
+    AllowMultiple = true)]
+public sealed class ValueRangeAttribute : Attribute
+{
+    public ValueRangeAttribute(long from, long to)
+    {
+        From = from;
+        To = to;
+    }
+
+    public ValueRangeAttribute(ulong from, ulong to)
+    {
+        From = from;
+        To = to;
+    }
+
+    public ValueRangeAttribute(long value) => From = To = value;
+
+    public ValueRangeAttribute(ulong value) => From = To = value;
+
+    public object From { get; }
+    public object To { get; }
+}
+
+/// <summary>
+///     Indicates that the integral value never falls below zero.
+/// </summary>
+/// <example>
+///     <code>
+/// void Foo([NonNegativeValue] int value) {
+///   if (value == -1) { // Warning: Expression is always 'false'
+///     ...
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property |
+    AttributeTargets.Method | AttributeTargets.Delegate)]
+public sealed class NonNegativeValueAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that the function argument should be a string literal and match one
+///     of the parameters of the caller function. For example, ReSharper annotates
+///     the parameter of <see cref="System.ArgumentNullException" />.
+/// </summary>
+/// <example>
+///     <code>
+/// void Foo(string param) {
+///   if (param == null)
+///     throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Parameter)]
+public sealed class InvokerParameterNameAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that the method is contained in a type that implements
+///     <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
+///     is used to notify that some property value changed.
+/// </summary>
+/// <remarks>
+///     The method should be non-static and conform to one of the supported signatures:
+///     <list>
+///         <item>
+///             <c>NotifyChanged(string)</c>
+///         </item>
+///         <item>
+///             <c>NotifyChanged(params string[])</c>
+///         </item>
+///         <item>
+///             <c>NotifyChanged{T}(Expression{Func{T}})</c>
+///         </item>
+///         <item>
+///             <c>NotifyChanged{T,U}(Expression{Func{T,U}})</c>
+///         </item>
+///         <item>
+///             <c>SetProperty{T}(ref T, T, string)</c>
+///         </item>
+///     </list>
+/// </remarks>
+/// <example>
+///     <code>
+/// public class Foo : INotifyPropertyChanged {
+///   public event PropertyChangedEventHandler PropertyChanged;
+/// 
+///   [NotifyPropertyChangedInvocator]
+///   protected virtual void NotifyChanged(string propertyName) { ... }
+/// 
+///   string _name;
+/// 
+///   public string Name {
+///     get { return _name; }
+///     set { _name = value; NotifyChanged("LastName"); /* Warning */ }
+///   }
+/// }
+/// </code>
+///     Examples of generated notifications:
+///     <list>
+///         <item>
+///             <c>NotifyChanged("Property")</c>
+///         </item>
+///         <item>
+///             <c>NotifyChanged(() =&gt; Property)</c>
+///         </item>
+///         <item>
+///             <c>NotifyChanged((VM x) =&gt; x.Property)</c>
+///         </item>
+///         <item>
+///             <c>SetProperty(ref myField, value, "Property")</c>
+///         </item>
+///     </list>
+/// </example>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
+{
+    public NotifyPropertyChangedInvocatorAttribute()
+    {
+    }
+
+    public NotifyPropertyChangedInvocatorAttribute(
+        [NotNull]
+        string parameterName) => ParameterName = parameterName;
+
+    [CanBeNull]
+    public string ParameterName { get; }
+}
+
+/// <summary>
+///     Describes dependency between method input and output.
+/// </summary>
+/// <syntax>
+///     <p>Function Definition Table syntax:</p>
+///     <list>
+///         <item>FDT      ::= FDTRow [;FDTRow]*</item>
+///         <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
+///         <item>Input    ::= ParameterName: Value [, Input]*</item>
+///         <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
+///         <item>Value    ::= true | false | null | notnull | canbenull</item>
+///     </list>
+///     If the method has a single input parameter, its name could be omitted.<br />
+///     Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same) for the method output
+///     means that the method doesn't return normally (throws or terminates the process).<br />
+///     Value <c>canbenull</c> is only applicable for output parameters.<br />
+///     You can use multiple <c>[ContractAnnotation]</c> for each FDT row, or use single attribute
+///     with rows separated by semicolon. There is no notion of order rows, all rows are checked
+///     for applicability and applied per each program state tracked by the analysis engine.<br />
+/// </syntax>
+/// <examples>
+///     <list>
+///         <item>
+///             <code>
+/// [ContractAnnotation("=&gt; halt")]
+/// public void TerminationMethod()
+/// </code>
+///         </item>
+///         <item>
+///             <code>
+/// [ContractAnnotation("null &lt;= param:null")] // reverse condition syntax
+/// public string GetName(string surname)
+/// </code>
+///         </item>
+///         <item>
+///             <code>
+/// [ContractAnnotation("s:null =&gt; true")]
+/// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
+/// </code>
+///         </item>
+///         <item>
+///             <code>
+/// // A method that returns null if the parameter is null,
+/// // and not null if the parameter is not null
+/// [ContractAnnotation("null =&gt; null; notnull =&gt; notnull")]
+/// public object Transform(object data)
+/// </code>
+///         </item>
+///         <item>
+///             <code>
+/// [ContractAnnotation("=&gt; true, result: notnull; =&gt; false, result: null")]
+/// public bool TryParse(string s, out Person result)
+/// </code>
+///         </item>
+///     </list>
+/// </examples>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+public sealed class ContractAnnotationAttribute : Attribute
+{
+    public ContractAnnotationAttribute(
+        [NotNull]
+        string contract)
+        : this(contract, false)
+    {
+    }
+
+    public ContractAnnotationAttribute(
+        [NotNull]
+        string contract,
+        bool forceFullStates)
+    {
+        Contract = contract;
+        ForceFullStates = forceFullStates;
+    }
+
+    [NotNull]
+    public string Contract { get; }
+
+    public bool ForceFullStates { get; }
+}
+
+/// <summary>
+///     Indicates whether the marked element should be localized.
+/// </summary>
+/// <example>
+///     <code>
+/// [LocalizationRequiredAttribute(true)]
+/// class Foo {
+///   string str = "my string"; // Warning: Localizable string
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.All)]
+public sealed class LocalizationRequiredAttribute : Attribute
+{
+    public LocalizationRequiredAttribute() : this(true)
+    {
+    }
+
+    public LocalizationRequiredAttribute(bool required) => Required = required;
+
+    public bool Required { get; }
+}
+
+/// <summary>
+///     Indicates that the value of the marked type (or its derivatives)
+///     cannot be compared using '==' or '!=' operators and <c>Equals()</c>
+///     should be used instead. However, using '==' or '!=' for comparison
+///     with <c>null</c> is always permitted.
+/// </summary>
+/// <example>
+///     <code>
+/// [CannotApplyEqualityOperator]
+/// class NoEquality { }
+/// 
+/// class UsesNoEquality {
+///   void Test() {
+///     var ca1 = new NoEquality();
+///     var ca2 = new NoEquality();
+///     if (ca1 != null) { // OK
+///       bool condition = ca1 == ca2; // Warning
+///     }
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)]
+public sealed class CannotApplyEqualityOperatorAttribute : Attribute
+{
+}
+
+/// <summary>
+///     When applied to a target attribute, specifies a requirement for any type marked
+///     with the target attribute to implement or inherit specific type or types.
+/// </summary>
+/// <example>
+///     <code>
+/// [BaseTypeRequired(typeof(IComponent)] // Specify requirement
+/// class ComponentAttribute : Attribute { }
+/// 
+/// [Component] // ComponentAttribute requires implementing IComponent interface
+/// class MyComponent : IComponent { }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+[BaseTypeRequired(typeof(Attribute))]
+public sealed class BaseTypeRequiredAttribute : Attribute
+{
+    public BaseTypeRequiredAttribute(
+        [NotNull]
+        Type baseType) => BaseType = baseType;
+
+    [NotNull]
+    public Type BaseType { get; }
+}
+
+/// <summary>
+///     Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
+///     so this symbol will not be reported as unused (as well as by other usage inspections).
+/// </summary>
+[AttributeUsage(AttributeTargets.All)]
+public sealed class UsedImplicitlyAttribute : Attribute
+{
+    public UsedImplicitlyAttribute()
+        : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default)
+    {
+    }
+
+    public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
+        : this(useKindFlags, ImplicitUseTargetFlags.Default)
+    {
+    }
+
+    public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags)
+        : this(ImplicitUseKindFlags.Default, targetFlags)
+    {
+    }
+
+    public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
+    {
+        UseKindFlags = useKindFlags;
+        TargetFlags = targetFlags;
+    }
+
+    public ImplicitUseKindFlags UseKindFlags { get; }
+
+    public ImplicitUseTargetFlags TargetFlags { get; }
+}
+
+/// <summary>
+///     Can be applied to attributes, type parameters, and parameters of a type assignable from <see cref="System.Type" />
+///     .
+///     When applied to an attribute, the decorated attribute behaves the same as <see cref="UsedImplicitlyAttribute" />.
+///     When applied to a type parameter or to a parameter of type <see cref="System.Type" />,  indicates that the
+///     corresponding type
+///     is used implicitly.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter | AttributeTargets.Parameter)]
+public sealed class MeansImplicitUseAttribute : Attribute
+{
+    public MeansImplicitUseAttribute()
+        : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default)
+    {
+    }
+
+    public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
+        : this(useKindFlags, ImplicitUseTargetFlags.Default)
+    {
+    }
+
+    public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags)
+        : this(ImplicitUseKindFlags.Default, targetFlags)
+    {
+    }
+
+    public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
+    {
+        UseKindFlags = useKindFlags;
+        TargetFlags = targetFlags;
+    }
+
+    [UsedImplicitly]
+    public ImplicitUseKindFlags UseKindFlags { get; }
+
+    [UsedImplicitly]
+    public ImplicitUseTargetFlags TargetFlags { get; }
+}
+
+/// <summary>
+///     Specify the details of implicitly used symbol when it is marked
+///     with <see cref="MeansImplicitUseAttribute" /> or <see cref="UsedImplicitlyAttribute" />.
+/// </summary>
+[Flags]
+public enum ImplicitUseKindFlags
+{
+    Default = Access | Assign | InstantiatedWithFixedConstructorSignature,
+
+    /// <summary>Only entity marked with attribute considered used.</summary>
+    Access = 1,
+
+    /// <summary>Indicates implicit assignment to a member.</summary>
+    Assign = 2,
+
+    /// <summary>
+    ///     Indicates implicit instantiation of a type with fixed constructor signature.
+    ///     That means any unused constructor parameters won't be reported as such.
+    /// </summary>
+    InstantiatedWithFixedConstructorSignature = 4,
+
+    /// <summary>Indicates implicit instantiation of a type.</summary>
+    InstantiatedNoFixedConstructorSignature = 8
+}
+
+/// <summary>
+///     Specify what is considered to be used implicitly when marked
+///     with <see cref="MeansImplicitUseAttribute" /> or <see cref="UsedImplicitlyAttribute" />.
+/// </summary>
+[Flags]
+public enum ImplicitUseTargetFlags
+{
+    Default = Itself,
+    Itself = 1,
+
+    /// <summary>Members of entity marked with attribute are considered used.</summary>
+    Members = 2,
+
+    /// <summary> Inherited entities are considered used. </summary>
+    WithInheritors = 4,
+
+    /// <summary>Entity marked with attribute and all its members considered used.</summary>
+    WithMembers = Itself | Members
+}
+
+/// <summary>
+///     This attribute is intended to mark publicly available API
+///     which should not be removed and so is treated as used.
+/// </summary>
+[MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)]
+[AttributeUsage(AttributeTargets.All, Inherited = false)]
+public sealed class PublicAPIAttribute : Attribute
+{
+    public PublicAPIAttribute()
+    {
+    }
+
+    public PublicAPIAttribute(
+        [NotNull]
+        string comment) => Comment = comment;
+
+    [CanBeNull]
+    public string Comment { get; }
+}
+
+/// <summary>
+///     Tells code analysis engine if the parameter is completely handled when the invoked method is on stack.
+///     If the parameter is a delegate, indicates that delegate is executed while the method is executed.
+///     If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter)]
+public sealed class InstantHandleAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that a method does not make any observable state changes.
+///     The same as <c>System.Diagnostics.Contracts.PureAttribute</c>.
+/// </summary>
+/// <example>
+///     <code>
+/// [Pure] int Multiply(int x, int y) => x * y;
+/// 
+/// void M() {
+///   Multiply(123, 42); // Warning: Return value of pure method is not used
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class PureAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that the return value of the method invocation must be used.
+/// </summary>
+/// <remarks>
+///     Methods decorated with this attribute (in contrast to pure methods) might change state,
+///     but make no sense without using their return value. <br />
+///     Similarly to <see cref="PureAttribute" />, this attribute
+///     will help detecting usages of the method when the return value in not used.
+///     Additionally, you can optionally specify a custom message, which will be used when showing warnings, e.g.
+///     <code>[MustUseReturnValue("Use the return value to...")]</code>.
+/// </remarks>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class MustUseReturnValueAttribute : Attribute
+{
+    public MustUseReturnValueAttribute()
+    {
+    }
+
+    public MustUseReturnValueAttribute(
+        [NotNull]
+        string justification) => Justification = justification;
+
+    [CanBeNull]
+    public string Justification { get; }
+}
+
+/// <summary>
+///     Indicates the type member or parameter of some type, that should be used instead of all other ways
+///     to get the value of that type. This annotation is useful when you have some "context" value evaluated
+///     and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
+/// </summary>
+/// <example>
+///     <code>
+/// class Foo {
+///   [ProvidesContext] IBarService _barService = ...;
+/// 
+///   void ProcessNode(INode node) {
+///     DoSomething(node, node.GetGlobalServices().Bar);
+///     //              ^ Warning: use value of '_barService' field
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(
+    AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.Method |
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct |
+    AttributeTargets.GenericParameter)]
+public sealed class ProvidesContextAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that a parameter is a path to a file or a folder within a web project.
+///     Path can be relative or absolute, starting from web root (~).
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter)]
+public sealed class PathReferenceAttribute : Attribute
+{
+    public PathReferenceAttribute()
+    {
+    }
+
+    public PathReferenceAttribute(
+        [NotNull] [PathReference]
+        string basePath) => BasePath = basePath;
+
+    [CanBeNull]
+    public string BasePath { get; }
+}
+
+/// <summary>
+///     An extension method marked with this attribute is processed by code completion
+///     as a 'Source Template'. When the extension method is completed over some expression, its source code
+///     is automatically expanded like a template at call site.
+/// </summary>
+/// <remarks>
+///     Template method body can contain valid source code and/or special comments starting with '$'.
+///     Text inside these comments is added as source code when the template is applied. Template parameters
+///     can be used either as additional method parameters or as identifiers wrapped in two '$' signs.
+///     Use the <see cref="MacroAttribute" /> attribute to specify macros for parameters.
+/// </remarks>
+/// <example>
+///     In this example, the 'forEach' method is a source template available over all values
+///     of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block:
+///     <code>
+/// [SourceTemplate]
+/// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; xs) {
+///   foreach (var x in xs) {
+///      //$ $END$
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class SourceTemplateAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Allows specifying a macro for a parameter of a <see cref="SourceTemplateAttribute">source template</see>.
+/// </summary>
+/// <remarks>
+///     You can apply the attribute on the whole method or on any of its additional parameters. The macro expression
+///     is defined in the <see cref="MacroAttribute.Expression" /> property. When applied on a method, the target
+///     template parameter is defined in the <see cref="MacroAttribute.Target" /> property. To apply the macro silently
+///     for the parameter, set the <see cref="MacroAttribute.Editable" /> property value = -1.
+/// </remarks>
+/// <example>
+///     Applying the attribute on a source template method:
+///     <code>
+/// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
+/// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; collection) {
+///   foreach (var item in collection) {
+///     //$ $END$
+///   }
+/// }
+/// </code>
+///     Applying the attribute on a template method parameter:
+///     <code>
+/// [SourceTemplate]
+/// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) {
+///   /*$ var $x$Id = "$newguid$" + x.ToString();
+///   x.DoSomething($x$Id); */
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)]
+public sealed class MacroAttribute : Attribute
 {
     /// <summary>
-    ///     Indicates that the value of the marked element could be <c>null</c> sometimes,
-    ///     so checking for <c>null</c> is required before its usage.
+    ///     Allows specifying a macro that will be executed for a <see cref="SourceTemplateAttribute">source template</see>
+    ///     parameter when the template is expanded.
     /// </summary>
-    /// <example>
-    ///     <code>
-    /// [CanBeNull] object Test() => null;
-    /// 
-    /// void UseTest() {
-    ///   var p = Test();
-    ///   var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
-        AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event |
-        AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)]
-    public sealed class CanBeNullAttribute : Attribute
-    {
-    }
+    [CanBeNull]
+    public string Expression { get; set; }
 
     /// <summary>
-    ///     Indicates that the value of the marked element can never be <c>null</c>.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// [NotNull] object Foo() {
-    ///   return null; // Warning: Possible 'null' assignment
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
-        AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event |
-        AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)]
-    public sealed class NotNullAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task
-    ///     and Lazy classes to indicate that the value of a collection item, of the Task.Result property
-    ///     or of the Lazy.Value property can never be null.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// public void Foo([ItemNotNull]List&lt;string&gt; books)
-    /// {
-    ///   foreach (var book in books) {
-    ///     if (book != null) // Warning: Expression is always true
-    ///      Console.WriteLine(book.ToUpper());
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
-        AttributeTargets.Delegate | AttributeTargets.Field)]
-    public sealed class ItemNotNullAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task
-    ///     and Lazy classes to indicate that the value of a collection item, of the Task.Result property
-    ///     or of the Lazy.Value property can be null.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// public void Foo([ItemCanBeNull]List&lt;string&gt; books)
-    /// {
-    ///   foreach (var book in books)
-    ///   {
-    ///     // Warning: Possible 'System.NullReferenceException'
-    ///     Console.WriteLine(book.ToUpper());
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property |
-        AttributeTargets.Delegate | AttributeTargets.Field)]
-    public sealed class ItemCanBeNullAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that the marked method builds string by the format pattern and (optional) arguments.
-    ///     The parameter, which contains the format string, should be given in constructor. The format string
-    ///     should be in <see cref="string.Format(IFormatProvider,string,object[])" />-like form.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// [StringFormatMethod("message")]
-    /// void ShowError(string message, params object[] args) { /* do something */ }
-    /// 
-    /// void Foo() {
-    ///   ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Constructor | AttributeTargets.Method |
-        AttributeTargets.Property | AttributeTargets.Delegate)]
-    public sealed class StringFormatMethodAttribute : Attribute
-    {
-        /// <param name="formatParameterName">
-        ///     Specifies which parameter of an annotated method should be treated as the format string
-        /// </param>
-        public StringFormatMethodAttribute(
-            [NotNull]
-            string formatParameterName) => FormatParameterName = formatParameterName;
-
-        [NotNull]
-        public string FormatParameterName { get; }
-    }
-
-    /// <summary>
-    ///     Use this annotation to specify a type that contains static or const fields
-    ///     with values for the annotated property/field/parameter.
-    ///     The specified type will be used to improve completion suggestions.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// namespace TestNamespace
-    /// {
-    ///   public class Constants
-    ///   {
-    ///     public static int INT_CONST = 1;
-    ///     public const string STRING_CONST = "1";
-    ///   }
-    /// 
-    ///   public class Class1
-    ///   {
-    ///     [ValueProvider("TestNamespace.Constants")] public int myField;
-    ///     public void Foo([ValueProvider("TestNamespace.Constants")] string str) { }
-    /// 
-    ///     public void Test()
-    ///     {
-    ///       Foo(/*try completion here*/);//
-    ///       myField = /*try completion here*/
-    ///     }
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field,
-        AllowMultiple = true)]
-    public sealed class ValueProviderAttribute : Attribute
-    {
-        public ValueProviderAttribute(
-            [NotNull]
-            string name) => Name = name;
-
-        [NotNull]
-        public string Name { get; }
-    }
-
-    /// <summary>
-    ///     Indicates that the integral value falls into the specified interval.
-    ///     It's allowed to specify multiple non-intersecting intervals.
-    ///     Values of interval boundaries are inclusive.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// void Foo([ValueRange(0, 100)] int value) {
-    ///   if (value == -1) { // Warning: Expression is always 'false'
-    ///     ...
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property |
-        AttributeTargets.Method | AttributeTargets.Delegate,
-        AllowMultiple = true)]
-    public sealed class ValueRangeAttribute : Attribute
-    {
-        public ValueRangeAttribute(long from, long to)
-        {
-            From = from;
-            To = to;
-        }
-
-        public ValueRangeAttribute(ulong from, ulong to)
-        {
-            From = from;
-            To = to;
-        }
-
-        public ValueRangeAttribute(long value) => From = To = value;
-
-        public ValueRangeAttribute(ulong value) => From = To = value;
-
-        public object From { get; }
-        public object To { get; }
-    }
-
-    /// <summary>
-    ///     Indicates that the integral value never falls below zero.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// void Foo([NonNegativeValue] int value) {
-    ///   if (value == -1) { // Warning: Expression is always 'false'
-    ///     ...
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property |
-        AttributeTargets.Method | AttributeTargets.Delegate)]
-    public sealed class NonNegativeValueAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that the function argument should be a string literal and match one
-    ///     of the parameters of the caller function. For example, ReSharper annotates
-    ///     the parameter of <see cref="System.ArgumentNullException" />.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// void Foo(string param) {
-    ///   if (param == null)
-    ///     throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Parameter)]
-    public sealed class InvokerParameterNameAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that the method is contained in a type that implements
-    ///     <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
-    ///     is used to notify that some property value changed.
+    ///     Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
     /// </summary>
     /// <remarks>
-    ///     The method should be non-static and conform to one of the supported signatures:
-    ///     <list>
-    ///         <item>
-    ///             <c>NotifyChanged(string)</c>
-    ///         </item>
-    ///         <item>
-    ///             <c>NotifyChanged(params string[])</c>
-    ///         </item>
-    ///         <item>
-    ///             <c>NotifyChanged{T}(Expression{Func{T}})</c>
-    ///         </item>
-    ///         <item>
-    ///             <c>NotifyChanged{T,U}(Expression{Func{T,U}})</c>
-    ///         </item>
-    ///         <item>
-    ///             <c>SetProperty{T}(ref T, T, string)</c>
-    ///         </item>
-    ///     </list>
+    ///     If the target parameter is used several times in the template, only one occurrence becomes editable;
+    ///     other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence,
+    ///     use values >= 0. To make the parameter non-editable when the template is expanded, use -1.
     /// </remarks>
-    /// <example>
-    ///     <code>
-    /// public class Foo : INotifyPropertyChanged {
-    ///   public event PropertyChangedEventHandler PropertyChanged;
-    /// 
-    ///   [NotifyPropertyChangedInvocator]
-    ///   protected virtual void NotifyChanged(string propertyName) { ... }
-    /// 
-    ///   string _name;
-    /// 
-    ///   public string Name {
-    ///     get { return _name; }
-    ///     set { _name = value; NotifyChanged("LastName"); /* Warning */ }
-    ///   }
-    /// }
-    /// </code>
-    ///     Examples of generated notifications:
-    ///     <list>
-    ///         <item>
-    ///             <c>NotifyChanged("Property")</c>
-    ///         </item>
-    ///         <item>
-    ///             <c>NotifyChanged(() =&gt; Property)</c>
-    ///         </item>
-    ///         <item>
-    ///             <c>NotifyChanged((VM x) =&gt; x.Property)</c>
-    ///         </item>
-    ///         <item>
-    ///             <c>SetProperty(ref myField, value, "Property")</c>
-    ///         </item>
-    ///     </list>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute
-    {
-        public NotifyPropertyChangedInvocatorAttribute()
-        {
-        }
-
-        public NotifyPropertyChangedInvocatorAttribute(
-            [NotNull]
-            string parameterName) => ParameterName = parameterName;
-
-        [CanBeNull]
-        public string ParameterName { get; }
-    }
+    public int Editable { get; set; }
 
     /// <summary>
-    ///     Describes dependency between method input and output.
+    ///     Identifies the target parameter of a <see cref="SourceTemplateAttribute">source template</see> if the
+    ///     <see cref="MacroAttribute" /> is applied on a template method.
     /// </summary>
-    /// <syntax>
-    ///     <p>Function Definition Table syntax:</p>
-    ///     <list>
-    ///         <item>FDT      ::= FDTRow [;FDTRow]*</item>
-    ///         <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
-    ///         <item>Input    ::= ParameterName: Value [, Input]*</item>
-    ///         <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
-    ///         <item>Value    ::= true | false | null | notnull | canbenull</item>
-    ///     </list>
-    ///     If the method has a single input parameter, its name could be omitted.<br />
-    ///     Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same) for the method output
-    ///     means that the method doesn't return normally (throws or terminates the process).<br />
-    ///     Value <c>canbenull</c> is only applicable for output parameters.<br />
-    ///     You can use multiple <c>[ContractAnnotation]</c> for each FDT row, or use single attribute
-    ///     with rows separated by semicolon. There is no notion of order rows, all rows are checked
-    ///     for applicability and applied per each program state tracked by the analysis engine.<br />
-    /// </syntax>
-    /// <examples>
-    ///     <list>
-    ///         <item>
-    ///             <code>
-    /// [ContractAnnotation("=&gt; halt")]
-    /// public void TerminationMethod()
-    /// </code>
-    ///         </item>
-    ///         <item>
-    ///             <code>
-    /// [ContractAnnotation("null &lt;= param:null")] // reverse condition syntax
-    /// public string GetName(string surname)
-    /// </code>
-    ///         </item>
-    ///         <item>
-    ///             <code>
-    /// [ContractAnnotation("s:null =&gt; true")]
-    /// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
-    /// </code>
-    ///         </item>
-    ///         <item>
-    ///             <code>
-    /// // A method that returns null if the parameter is null,
-    /// // and not null if the parameter is not null
-    /// [ContractAnnotation("null =&gt; null; notnull =&gt; notnull")]
-    /// public object Transform(object data)
-    /// </code>
-    ///         </item>
-    ///         <item>
-    ///             <code>
-    /// [ContractAnnotation("=&gt; true, result: notnull; =&gt; false, result: null")]
-    /// public bool TryParse(string s, out Person result)
-    /// </code>
-    ///         </item>
-    ///     </list>
-    /// </examples>
-    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
-    public sealed class ContractAnnotationAttribute : Attribute
-    {
-        public ContractAnnotationAttribute(
-            [NotNull]
-            string contract)
-            : this(contract, false)
-        {
-        }
-
-        public ContractAnnotationAttribute(
-            [NotNull]
-            string contract,
-            bool forceFullStates)
-        {
-            Contract = contract;
-            ForceFullStates = forceFullStates;
-        }
-
-        [NotNull]
-        public string Contract { get; }
-
-        public bool ForceFullStates { get; }
-    }
-
-    /// <summary>
-    ///     Indicates whether the marked element should be localized.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// [LocalizationRequiredAttribute(true)]
-    /// class Foo {
-    ///   string str = "my string"; // Warning: Localizable string
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.All)]
-    public sealed class LocalizationRequiredAttribute : Attribute
-    {
-        public LocalizationRequiredAttribute() : this(true)
-        {
-        }
-
-        public LocalizationRequiredAttribute(bool required) => Required = required;
-
-        public bool Required { get; }
-    }
-
-    /// <summary>
-    ///     Indicates that the value of the marked type (or its derivatives)
-    ///     cannot be compared using '==' or '!=' operators and <c>Equals()</c>
-    ///     should be used instead. However, using '==' or '!=' for comparison
-    ///     with <c>null</c> is always permitted.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// [CannotApplyEqualityOperator]
-    /// class NoEquality { }
-    /// 
-    /// class UsesNoEquality {
-    ///   void Test() {
-    ///     var ca1 = new NoEquality();
-    ///     var ca2 = new NoEquality();
-    ///     if (ca1 != null) { // OK
-    ///       bool condition = ca1 == ca2; // Warning
-    ///     }
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)]
-    public sealed class CannotApplyEqualityOperatorAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     When applied to a target attribute, specifies a requirement for any type marked
-    ///     with the target attribute to implement or inherit specific type or types.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement
-    /// class ComponentAttribute : Attribute { }
-    /// 
-    /// [Component] // ComponentAttribute requires implementing IComponent interface
-    /// class MyComponent : IComponent { }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
-    [BaseTypeRequired(typeof(Attribute))]
-    public sealed class BaseTypeRequiredAttribute : Attribute
-    {
-        public BaseTypeRequiredAttribute(
-            [NotNull]
-            Type baseType) => BaseType = baseType;
-
-        [NotNull]
-        public Type BaseType { get; }
-    }
-
-    /// <summary>
-    ///     Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
-    ///     so this symbol will not be reported as unused (as well as by other usage inspections).
-    /// </summary>
-    [AttributeUsage(AttributeTargets.All)]
-    public sealed class UsedImplicitlyAttribute : Attribute
-    {
-        public UsedImplicitlyAttribute()
-            : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default)
-        {
-        }
-
-        public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags)
-            : this(useKindFlags, ImplicitUseTargetFlags.Default)
-        {
-        }
-
-        public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags)
-            : this(ImplicitUseKindFlags.Default, targetFlags)
-        {
-        }
-
-        public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
-        {
-            UseKindFlags = useKindFlags;
-            TargetFlags = targetFlags;
-        }
-
-        public ImplicitUseKindFlags UseKindFlags { get; }
-
-        public ImplicitUseTargetFlags TargetFlags { get; }
-    }
-
-    /// <summary>
-    ///     Can be applied to attributes, type parameters, and parameters of a type assignable from <see cref="System.Type" />
-    ///     .
-    ///     When applied to an attribute, the decorated attribute behaves the same as <see cref="UsedImplicitlyAttribute" />.
-    ///     When applied to a type parameter or to a parameter of type <see cref="System.Type" />,  indicates that the
-    ///     corresponding type
-    ///     is used implicitly.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter | AttributeTargets.Parameter)]
-    public sealed class MeansImplicitUseAttribute : Attribute
-    {
-        public MeansImplicitUseAttribute()
-            : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default)
-        {
-        }
-
-        public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags)
-            : this(useKindFlags, ImplicitUseTargetFlags.Default)
-        {
-        }
-
-        public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags)
-            : this(ImplicitUseKindFlags.Default, targetFlags)
-        {
-        }
-
-        public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags)
-        {
-            UseKindFlags = useKindFlags;
-            TargetFlags = targetFlags;
-        }
-
-        [UsedImplicitly]
-        public ImplicitUseKindFlags UseKindFlags { get; }
-
-        [UsedImplicitly]
-        public ImplicitUseTargetFlags TargetFlags { get; }
-    }
-
-    /// <summary>
-    ///     Specify the details of implicitly used symbol when it is marked
-    ///     with <see cref="MeansImplicitUseAttribute" /> or <see cref="UsedImplicitlyAttribute" />.
-    /// </summary>
-    [Flags]
-    public enum ImplicitUseKindFlags
-    {
-        Default = Access | Assign | InstantiatedWithFixedConstructorSignature,
-
-        /// <summary>Only entity marked with attribute considered used.</summary>
-        Access = 1,
-
-        /// <summary>Indicates implicit assignment to a member.</summary>
-        Assign = 2,
-
-        /// <summary>
-        ///     Indicates implicit instantiation of a type with fixed constructor signature.
-        ///     That means any unused constructor parameters won't be reported as such.
-        /// </summary>
-        InstantiatedWithFixedConstructorSignature = 4,
-
-        /// <summary>Indicates implicit instantiation of a type.</summary>
-        InstantiatedNoFixedConstructorSignature = 8
-    }
-
-    /// <summary>
-    ///     Specify what is considered to be used implicitly when marked
-    ///     with <see cref="MeansImplicitUseAttribute" /> or <see cref="UsedImplicitlyAttribute" />.
-    /// </summary>
-    [Flags]
-    public enum ImplicitUseTargetFlags
-    {
-        Default = Itself,
-        Itself = 1,
-
-        /// <summary>Members of entity marked with attribute are considered used.</summary>
-        Members = 2,
-
-        /// <summary> Inherited entities are considered used. </summary>
-        WithInheritors = 4,
-
-        /// <summary>Entity marked with attribute and all its members considered used.</summary>
-        WithMembers = Itself | Members
-    }
-
-    /// <summary>
-    ///     This attribute is intended to mark publicly available API
-    ///     which should not be removed and so is treated as used.
-    /// </summary>
-    [MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)]
-    [AttributeUsage(AttributeTargets.All, Inherited = false)]
-    public sealed class PublicAPIAttribute : Attribute
-    {
-        public PublicAPIAttribute()
-        {
-        }
-
-        public PublicAPIAttribute(
-            [NotNull]
-            string comment) => Comment = comment;
-
-        [CanBeNull]
-        public string Comment { get; }
-    }
-
-    /// <summary>
-    ///     Tells code analysis engine if the parameter is completely handled when the invoked method is on stack.
-    ///     If the parameter is a delegate, indicates that delegate is executed while the method is executed.
-    ///     If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter)]
-    public sealed class InstantHandleAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that a method does not make any observable state changes.
-    ///     The same as <c>System.Diagnostics.Contracts.PureAttribute</c>.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// [Pure] int Multiply(int x, int y) => x * y;
-    /// 
-    /// void M() {
-    ///   Multiply(123, 42); // Warning: Return value of pure method is not used
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class PureAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that the return value of the method invocation must be used.
-    /// </summary>
-    /// <remarks>
-    ///     Methods decorated with this attribute (in contrast to pure methods) might change state,
-    ///     but make no sense without using their return value. <br />
-    ///     Similarly to <see cref="PureAttribute" />, this attribute
-    ///     will help detecting usages of the method when the return value in not used.
-    ///     Additionally, you can optionally specify a custom message, which will be used when showing warnings, e.g.
-    ///     <code>[MustUseReturnValue("Use the return value to...")]</code>.
-    /// </remarks>
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class MustUseReturnValueAttribute : Attribute
-    {
-        public MustUseReturnValueAttribute()
-        {
-        }
-
-        public MustUseReturnValueAttribute(
-            [NotNull]
-            string justification) => Justification = justification;
-
-        [CanBeNull]
-        public string Justification { get; }
-    }
-
-    /// <summary>
-    ///     Indicates the type member or parameter of some type, that should be used instead of all other ways
-    ///     to get the value of that type. This annotation is useful when you have some "context" value evaluated
-    ///     and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// class Foo {
-    ///   [ProvidesContext] IBarService _barService = ...;
-    /// 
-    ///   void ProcessNode(INode node) {
-    ///     DoSomething(node, node.GetGlobalServices().Bar);
-    ///     //              ^ Warning: use value of '_barService' field
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(
-        AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.Method |
-        AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct |
-        AttributeTargets.GenericParameter)]
-    public sealed class ProvidesContextAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that a parameter is a path to a file or a folder within a web project.
-    ///     Path can be relative or absolute, starting from web root (~).
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter)]
-    public sealed class PathReferenceAttribute : Attribute
-    {
-        public PathReferenceAttribute()
-        {
-        }
-
-        public PathReferenceAttribute(
-            [NotNull] [PathReference]
-            string basePath) => BasePath = basePath;
-
-        [CanBeNull]
-        public string BasePath { get; }
-    }
-
-    /// <summary>
-    ///     An extension method marked with this attribute is processed by code completion
-    ///     as a 'Source Template'. When the extension method is completed over some expression, its source code
-    ///     is automatically expanded like a template at call site.
-    /// </summary>
-    /// <remarks>
-    ///     Template method body can contain valid source code and/or special comments starting with '$'.
-    ///     Text inside these comments is added as source code when the template is applied. Template parameters
-    ///     can be used either as additional method parameters or as identifiers wrapped in two '$' signs.
-    ///     Use the <see cref="MacroAttribute" /> attribute to specify macros for parameters.
-    /// </remarks>
-    /// <example>
-    ///     In this example, the 'forEach' method is a source template available over all values
-    ///     of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block:
-    ///     <code>
-    /// [SourceTemplate]
-    /// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; xs) {
-    ///   foreach (var x in xs) {
-    ///      //$ $END$
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class SourceTemplateAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Allows specifying a macro for a parameter of a <see cref="SourceTemplateAttribute">source template</see>.
-    /// </summary>
-    /// <remarks>
-    ///     You can apply the attribute on the whole method or on any of its additional parameters. The macro expression
-    ///     is defined in the <see cref="MacroAttribute.Expression" /> property. When applied on a method, the target
-    ///     template parameter is defined in the <see cref="MacroAttribute.Target" /> property. To apply the macro silently
-    ///     for the parameter, set the <see cref="MacroAttribute.Editable" /> property value = -1.
-    /// </remarks>
-    /// <example>
-    ///     Applying the attribute on a source template method:
-    ///     <code>
-    /// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
-    /// public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; collection) {
-    ///   foreach (var item in collection) {
-    ///     //$ $END$
-    ///   }
-    /// }
-    /// </code>
-    ///     Applying the attribute on a template method parameter:
-    ///     <code>
-    /// [SourceTemplate]
-    /// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) {
-    ///   /*$ var $x$Id = "$newguid$" + x.ToString();
-    ///   x.DoSomething($x$Id); */
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)]
-    public sealed class MacroAttribute : Attribute
-    {
-        /// <summary>
-        ///     Allows specifying a macro that will be executed for a <see cref="SourceTemplateAttribute">source template</see>
-        ///     parameter when the template is expanded.
-        /// </summary>
-        [CanBeNull]
-        public string Expression { get; set; }
-
-        /// <summary>
-        ///     Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
-        /// </summary>
-        /// <remarks>
-        ///     If the target parameter is used several times in the template, only one occurrence becomes editable;
-        ///     other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence,
-        ///     use values >= 0. To make the parameter non-editable when the template is expanded, use -1.
-        /// </remarks>
-        public int Editable { get; set; }
-
-        /// <summary>
-        ///     Identifies the target parameter of a <see cref="SourceTemplateAttribute">source template</see> if the
-        ///     <see cref="MacroAttribute" /> is applied on a template method.
-        /// </summary>
-        [CanBeNull]
-        public string Target { get; set; }
-    }
-
-    [AttributeUsage(
-        AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
-        AllowMultiple = true)]
-    public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute
-    {
-        public AspMvcAreaMasterLocationFormatAttribute(
-            [NotNull]
-            string format) => Format = format;
-
-        [NotNull]
-        public string Format { get; }
-    }
-
-    [AttributeUsage(
-        AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
-        AllowMultiple = true)]
-    public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute
-    {
-        public AspMvcAreaPartialViewLocationFormatAttribute(
-            [NotNull]
-            string format) => Format = format;
-
-        [NotNull]
-        public string Format { get; }
-    }
-
-    [AttributeUsage(
-        AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
-        AllowMultiple = true)]
-    public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute
-    {
-        public AspMvcAreaViewLocationFormatAttribute(
-            [NotNull]
-            string format) => Format = format;
-
-        [NotNull]
-        public string Format { get; }
-    }
-
-    [AttributeUsage(
-        AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
-        AllowMultiple = true)]
-    public sealed class AspMvcMasterLocationFormatAttribute : Attribute
-    {
-        public AspMvcMasterLocationFormatAttribute(
-            [NotNull]
-            string format) => Format = format;
-
-        [NotNull]
-        public string Format { get; }
-    }
-
-    [AttributeUsage(
-        AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
-        AllowMultiple = true)]
-    public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute
-    {
-        public AspMvcPartialViewLocationFormatAttribute(
-            [NotNull]
-            string format) => Format = format;
-
-        [NotNull]
-        public string Format { get; }
-    }
-
-    [AttributeUsage(
-        AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
-        AllowMultiple = true)]
-    public sealed class AspMvcViewLocationFormatAttribute : Attribute
-    {
-        public AspMvcViewLocationFormatAttribute(
-            [NotNull]
-            string format) => Format = format;
-
-        [NotNull]
-        public string Format { get; }
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
-    ///     is an MVC action. If applied to a method, the MVC action name is calculated
-    ///     implicitly from the context. Use this attribute for custom wrappers similar to
-    ///     <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
-    /// </summary>
-    [AttributeUsage(
-        AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcActionAttribute : Attribute
-    {
-        public AspMvcActionAttribute()
-        {
-        }
-
-        public AspMvcActionAttribute(
-            [NotNull]
-            string anonymousProperty) => AnonymousProperty = anonymousProperty;
-
-        [CanBeNull]
-        public string AnonymousProperty { get; }
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC area.
-    ///     Use this attribute for custom wrappers similar to
-    ///     <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcAreaAttribute : Attribute
-    {
-        public AspMvcAreaAttribute()
-        {
-        }
-
-        public AspMvcAreaAttribute(
-            [NotNull]
-            string anonymousProperty) => AnonymousProperty = anonymousProperty;
-
-        [CanBeNull]
-        public string AnonymousProperty { get; }
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is
-    ///     an MVC controller. If applied to a method, the MVC controller name is calculated
-    ///     implicitly from the context. Use this attribute for custom wrappers similar to
-    ///     <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String)</c>.
-    /// </summary>
-    [AttributeUsage(
-        AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcControllerAttribute : Attribute
-    {
-        public AspMvcControllerAttribute()
-        {
-        }
-
-        public AspMvcControllerAttribute(
-            [NotNull]
-            string anonymousProperty) => AnonymousProperty = anonymousProperty;
-
-        [CanBeNull]
-        public string AnonymousProperty { get; }
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC Master. Use this attribute
-    ///     for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, String)</c>.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcMasterAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC model type. Use this attribute
-    ///     for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, Object)</c>.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter)]
-    public sealed class AspMvcModelTypeAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC
-    ///     partial view. If applied to a method, the MVC partial view name is calculated implicitly
-    ///     from the context. Use this attribute for custom wrappers similar to
-    ///     <c>System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String)</c>.
-    /// </summary>
-    [AttributeUsage(
-        AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcPartialViewAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
-    public sealed class AspMvcSuppressViewErrorAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
-    ///     Use this attribute for custom wrappers similar to
-    ///     <c>System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String)</c>.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcDisplayTemplateAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC editor template.
-    ///     Use this attribute for custom wrappers similar to
-    ///     <c>System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String)</c>.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcEditorTemplateAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC template.
-    ///     Use this attribute for custom wrappers similar to
-    ///     <c>System.ComponentModel.DataAnnotations.UIHintAttribute(System.String)</c>.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcTemplateAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
-    ///     is an MVC view component. If applied to a method, the MVC view name is calculated implicitly
-    ///     from the context. Use this attribute for custom wrappers similar to
-    ///     <c>System.Web.Mvc.Controller.View(Object)</c>.
-    /// </summary>
-    [AttributeUsage(
-        AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcViewAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
-    ///     is an MVC view component name.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcViewComponentAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
-    ///     is an MVC view component view. If applied to a method, the MVC view component view name is default.
-    /// </summary>
-    [AttributeUsage(
-        AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class AspMvcViewComponentViewAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     ASP.NET MVC attribute. When applied to a parameter of an attribute,
-    ///     indicates that this parameter is an MVC action name.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// [ActionName("Foo")]
-    /// public ActionResult Login(string returnUrl) {
-    ///   ViewBag.ReturnUrl = Url.Action("Foo"); // OK
-    ///   return RedirectToAction("Bar"); // Error: Cannot resolve action
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)]
-    public sealed class AspMvcActionSelectorAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
-    public sealed class HtmlElementAttributesAttribute : Attribute
-    {
-        public HtmlElementAttributesAttribute()
-        {
-        }
-
-        public HtmlElementAttributesAttribute(
-            [NotNull]
-            string name) => Name = name;
-
-        [CanBeNull]
-        public string Name { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class HtmlAttributeValueAttribute : Attribute
-    {
-        public HtmlAttributeValueAttribute(
-            [NotNull]
-            string name) => Name = name;
-
-        [NotNull]
-        public string Name { get; }
-    }
-
-    /// <summary>
-    ///     Razor attribute. Indicates that the marked parameter or method is a Razor section.
-    ///     Use this attribute for custom wrappers similar to
-    ///     <c>System.Web.WebPages.WebPageBase.RenderSection(String)</c>.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
-    public sealed class RazorSectionAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates how method, constructor invocation, or property access
-    ///     over collection type affects the contents of the collection.
-    ///     Use <see cref="CollectionAccessType" /> to specify the access type.
-    /// </summary>
-    /// <remarks>
-    ///     Using this attribute only makes sense if all collection methods are marked with this attribute.
-    /// </remarks>
-    /// <example>
-    ///     <code>
-    /// public class MyStringCollection : List&lt;string&gt;
-    /// {
-    ///   [CollectionAccess(CollectionAccessType.Read)]
-    ///   public string GetFirstString()
-    ///   {
-    ///     return this.ElementAt(0);
-    ///   }
-    /// }
-    /// class Test
-    /// {
-    ///   public void Foo()
-    ///   {
-    ///     // Warning: Contents of the collection is never updated
-    ///     var col = new MyStringCollection();
-    ///     string x = col.GetFirstString();
-    ///   }
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)]
-    public sealed class CollectionAccessAttribute : Attribute
-    {
-        public CollectionAccessAttribute(CollectionAccessType collectionAccessType) =>
-            CollectionAccessType = collectionAccessType;
-
-        public CollectionAccessType CollectionAccessType { get; }
-    }
-
-    /// <summary>
-    ///     Provides a value for the <see cref="CollectionAccessAttribute" /> to define
-    ///     how the collection method invocation affects the contents of the collection.
-    /// </summary>
-    [Flags]
-    public enum CollectionAccessType
-    {
-        /// <summary>Method does not use or modify content of the collection.</summary>
-        None = 0,
-
-        /// <summary>Method only reads content of the collection but does not modify it.</summary>
-        Read = 1,
-
-        /// <summary>Method can change content of the collection but does not add new elements.</summary>
-        ModifyExistingContent = 2,
-
-        /// <summary>Method can add new elements to the collection.</summary>
-        UpdatedContent = ModifyExistingContent | 4
-    }
-
-    /// <summary>
-    ///     Indicates that the marked method is assertion method, i.e. it halts the control flow if
-    ///     one of the conditions is satisfied. To set the condition, mark one of the parameters with
-    ///     <see cref="AssertionConditionAttribute" /> attribute.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class AssertionMethodAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates the condition parameter of the assertion method. The method itself should be
-    ///     marked by <see cref="AssertionMethodAttribute" /> attribute. The mandatory argument of
-    ///     the attribute is the assertion type.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter)]
-    public sealed class AssertionConditionAttribute : Attribute
-    {
-        public AssertionConditionAttribute(AssertionConditionType conditionType) => ConditionType = conditionType;
-
-        public AssertionConditionType ConditionType { get; }
-    }
-
-    /// <summary>
-    ///     Specifies assertion type. If the assertion method argument satisfies the condition,
-    ///     then the execution continues. Otherwise, execution is assumed to be halted.
-    /// </summary>
-    public enum AssertionConditionType
-    {
-        /// <summary>Marked parameter should be evaluated to true.</summary>
-        IS_TRUE = 0,
-
-        /// <summary>Marked parameter should be evaluated to false.</summary>
-        IS_FALSE = 1,
-
-        /// <summary>Marked parameter should be evaluated to null value.</summary>
-        IS_NULL = 2,
-
-        /// <summary>Marked parameter should be evaluated to not null value.</summary>
-        IS_NOT_NULL = 3
-    }
-
-    /// <summary>
-    ///     Indicates that the marked method unconditionally terminates control flow execution.
-    ///     For example, it could unconditionally throw exception.
-    /// </summary>
-    [Obsolete("Use [ContractAnnotation('=> halt')] instead")]
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class TerminatesProgramAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select,
-    ///     .Where). This annotation allows inference of [InstantHandle] annotation for parameters
-    ///     of delegate type by analyzing LINQ method chains.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class LinqTunnelAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that IEnumerable passed as a parameter is not enumerated.
-    ///     Use this annotation to suppress the 'Possible multiple enumeration of IEnumerable' inspection.
-    /// </summary>
-    /// <example>
-    ///     <code>
-    /// static void ThrowIfNull&lt;T&gt;([NoEnumeration] T v, string n) where T : class
-    /// {
-    ///   // custom check for null but no enumeration
-    /// }
-    /// 
-    /// void Foo(IEnumerable&lt;string&gt; values)
-    /// {
-    ///   ThrowIfNull(values, nameof(values));
-    ///   var x = values.ToList(); // No warnings about multiple enumeration
-    /// }
-    /// </code>
-    /// </example>
-    [AttributeUsage(AttributeTargets.Parameter)]
-    public sealed class NoEnumerationAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Indicates that the marked parameter is a regular expression pattern.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
-    public sealed class RegexPatternAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     Prevents the Member Reordering feature from tossing members of the marked class.
-    /// </summary>
-    /// <remarks>
-    ///     The attribute must be mentioned in your member reordering patterns.
-    /// </remarks>
-    [AttributeUsage(
-        AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.Enum)]
-    public sealed class NoReorderAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be treated
-    ///     as <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolve.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Class)]
-    public sealed class XamlItemsControlAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     XAML attribute. Indicates the property of some <c>BindingBase</c>-derived type, that
-    ///     is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
-    ///     enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
-    /// </summary>
-    /// <remarks>
-    ///     Property should have the tree ancestor of the <c>ItemsControl</c> type or
-    ///     marked with the <see cref="XamlItemsControlAttribute" /> attribute.
-    /// </remarks>
-    [AttributeUsage(AttributeTargets.Property)]
-    public sealed class XamlItemBindingOfItemsControlAttribute : Attribute
-    {
-    }
-
-    /// <summary>
-    ///     XAML attribute. Indicates the property of some <c>Style</c>-derived type, that
-    ///     is used to style items of <c>ItemsControl</c>-derived type. This annotation will
-    ///     enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
-    /// </summary>
-    /// <remarks>
-    ///     Property should have the tree ancestor of the <c>ItemsControl</c> type or
-    ///     marked with the <see cref="XamlItemsControlAttribute" /> attribute.
-    /// </remarks>
-    [AttributeUsage(AttributeTargets.Property)]
-    public sealed class XamlItemStyleOfItemsControlAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
-    public sealed class AspChildControlTypeAttribute : Attribute
-    {
-        public AspChildControlTypeAttribute(
-            [NotNull]
-            string tagName,
-            [NotNull]
-            Type controlType)
-        {
-            TagName = tagName;
-            ControlType = controlType;
-        }
-
-        [NotNull]
-        public string TagName { get; }
-
-        [NotNull]
-        public Type ControlType { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
-    public sealed class AspDataFieldAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
-    public sealed class AspDataFieldsAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Property)]
-    public sealed class AspMethodPropertyAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
-    public sealed class AspRequiredAttributeAttribute : Attribute
-    {
-        public AspRequiredAttributeAttribute(
-            [NotNull]
-            string attribute) => Attribute = attribute;
-
-        [NotNull]
-        public string Attribute { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Property)]
-    public sealed class AspTypePropertyAttribute : Attribute
-    {
-        public AspTypePropertyAttribute(bool createConstructorReferences) =>
-            CreateConstructorReferences = createConstructorReferences;
-
-        public bool CreateConstructorReferences { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
-    public sealed class RazorImportNamespaceAttribute : Attribute
-    {
-        public RazorImportNamespaceAttribute(
-            [NotNull]
-            string name) => Name = name;
-
-        [NotNull]
-        public string Name { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
-    public sealed class RazorInjectionAttribute : Attribute
-    {
-        public RazorInjectionAttribute(
-            [NotNull]
-            string type,
-            [NotNull]
-            string fieldName)
-        {
-            Type = type;
-            FieldName = fieldName;
-        }
-
-        [NotNull]
-        public string Type { get; }
-
-        [NotNull]
-        public string FieldName { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
-    public sealed class RazorDirectiveAttribute : Attribute
-    {
-        public RazorDirectiveAttribute(
-            [NotNull]
-            string directive) => Directive = directive;
-
-        [NotNull]
-        public string Directive { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
-    public sealed class RazorPageBaseTypeAttribute : Attribute
-    {
-        public RazorPageBaseTypeAttribute(
-            [NotNull]
-            string baseType) => BaseType = baseType;
-
-        public RazorPageBaseTypeAttribute(
-            [NotNull]
-            string baseType,
-            string pageName)
-        {
-            BaseType = baseType;
-            PageName = pageName;
-        }
-
-        [NotNull]
-        public string BaseType { get; }
-
-        [CanBeNull]
-        public string PageName { get; }
-    }
-
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class RazorHelperCommonAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Property)]
-    public sealed class RazorLayoutAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class RazorWriteLiteralMethodAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Method)]
-    public sealed class RazorWriteMethodAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.Parameter)]
-    public sealed class RazorWriteMethodParameterAttribute : Attribute
-    {
-    }
+    [CanBeNull]
+    public string Target { get; set; }
 }
+
+[AttributeUsage(
+    AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
+    AllowMultiple = true)]
+public sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute
+{
+    public AspMvcAreaMasterLocationFormatAttribute(
+        [NotNull]
+        string format) => Format = format;
+
+    [NotNull]
+    public string Format { get; }
+}
+
+[AttributeUsage(
+    AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
+    AllowMultiple = true)]
+public sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute
+{
+    public AspMvcAreaPartialViewLocationFormatAttribute(
+        [NotNull]
+        string format) => Format = format;
+
+    [NotNull]
+    public string Format { get; }
+}
+
+[AttributeUsage(
+    AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
+    AllowMultiple = true)]
+public sealed class AspMvcAreaViewLocationFormatAttribute : Attribute
+{
+    public AspMvcAreaViewLocationFormatAttribute(
+        [NotNull]
+        string format) => Format = format;
+
+    [NotNull]
+    public string Format { get; }
+}
+
+[AttributeUsage(
+    AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
+    AllowMultiple = true)]
+public sealed class AspMvcMasterLocationFormatAttribute : Attribute
+{
+    public AspMvcMasterLocationFormatAttribute(
+        [NotNull]
+        string format) => Format = format;
+
+    [NotNull]
+    public string Format { get; }
+}
+
+[AttributeUsage(
+    AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
+    AllowMultiple = true)]
+public sealed class AspMvcPartialViewLocationFormatAttribute : Attribute
+{
+    public AspMvcPartialViewLocationFormatAttribute(
+        [NotNull]
+        string format) => Format = format;
+
+    [NotNull]
+    public string Format { get; }
+}
+
+[AttributeUsage(
+    AttributeTargets.Assembly | AttributeTargets.Field | AttributeTargets.Property,
+    AllowMultiple = true)]
+public sealed class AspMvcViewLocationFormatAttribute : Attribute
+{
+    public AspMvcViewLocationFormatAttribute(
+        [NotNull]
+        string format) => Format = format;
+
+    [NotNull]
+    public string Format { get; }
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+///     is an MVC action. If applied to a method, the MVC action name is calculated
+///     implicitly from the context. Use this attribute for custom wrappers similar to
+///     <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
+/// </summary>
+[AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcActionAttribute : Attribute
+{
+    public AspMvcActionAttribute()
+    {
+    }
+
+    public AspMvcActionAttribute(
+        [NotNull]
+        string anonymousProperty) => AnonymousProperty = anonymousProperty;
+
+    [CanBeNull]
+    public string AnonymousProperty { get; }
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC area.
+///     Use this attribute for custom wrappers similar to
+///     <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcAreaAttribute : Attribute
+{
+    public AspMvcAreaAttribute()
+    {
+    }
+
+    public AspMvcAreaAttribute(
+        [NotNull]
+        string anonymousProperty) => AnonymousProperty = anonymousProperty;
+
+    [CanBeNull]
+    public string AnonymousProperty { get; }
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is
+///     an MVC controller. If applied to a method, the MVC controller name is calculated
+///     implicitly from the context. Use this attribute for custom wrappers similar to
+///     <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String)</c>.
+/// </summary>
+[AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcControllerAttribute : Attribute
+{
+    public AspMvcControllerAttribute()
+    {
+    }
+
+    public AspMvcControllerAttribute(
+        [NotNull]
+        string anonymousProperty) => AnonymousProperty = anonymousProperty;
+
+    [CanBeNull]
+    public string AnonymousProperty { get; }
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC Master. Use this attribute
+///     for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, String)</c>.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcMasterAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC model type. Use this attribute
+///     for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, Object)</c>.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter)]
+public sealed class AspMvcModelTypeAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC
+///     partial view. If applied to a method, the MVC partial view name is calculated implicitly
+///     from the context. Use this attribute for custom wrappers similar to
+///     <c>System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String)</c>.
+/// </summary>
+[AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcPartialViewAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+public sealed class AspMvcSuppressViewErrorAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
+///     Use this attribute for custom wrappers similar to
+///     <c>System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String)</c>.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcDisplayTemplateAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC editor template.
+///     Use this attribute for custom wrappers similar to
+///     <c>System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String)</c>.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcEditorTemplateAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. Indicates that the marked parameter is an MVC template.
+///     Use this attribute for custom wrappers similar to
+///     <c>System.ComponentModel.DataAnnotations.UIHintAttribute(System.String)</c>.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcTemplateAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+///     is an MVC view component. If applied to a method, the MVC view name is calculated implicitly
+///     from the context. Use this attribute for custom wrappers similar to
+///     <c>System.Web.Mvc.Controller.View(Object)</c>.
+/// </summary>
+[AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcViewAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+///     is an MVC view component name.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcViewComponentAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
+///     is an MVC view component view. If applied to a method, the MVC view component view name is default.
+/// </summary>
+[AttributeUsage(
+    AttributeTargets.Parameter | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class AspMvcViewComponentViewAttribute : Attribute
+{
+}
+
+/// <summary>
+///     ASP.NET MVC attribute. When applied to a parameter of an attribute,
+///     indicates that this parameter is an MVC action name.
+/// </summary>
+/// <example>
+///     <code>
+/// [ActionName("Foo")]
+/// public ActionResult Login(string returnUrl) {
+///   ViewBag.ReturnUrl = Url.Action("Foo"); // OK
+///   return RedirectToAction("Bar"); // Error: Cannot resolve action
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)]
+public sealed class AspMvcActionSelectorAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)]
+public sealed class HtmlElementAttributesAttribute : Attribute
+{
+    public HtmlElementAttributesAttribute()
+    {
+    }
+
+    public HtmlElementAttributesAttribute(
+        [NotNull]
+        string name) => Name = name;
+
+    [CanBeNull]
+    public string Name { get; }
+}
+
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class HtmlAttributeValueAttribute : Attribute
+{
+    public HtmlAttributeValueAttribute(
+        [NotNull]
+        string name) => Name = name;
+
+    [NotNull]
+    public string Name { get; }
+}
+
+/// <summary>
+///     Razor attribute. Indicates that the marked parameter or method is a Razor section.
+///     Use this attribute for custom wrappers similar to
+///     <c>System.Web.WebPages.WebPageBase.RenderSection(String)</c>.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)]
+public sealed class RazorSectionAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates how method, constructor invocation, or property access
+///     over collection type affects the contents of the collection.
+///     Use <see cref="CollectionAccessType" /> to specify the access type.
+/// </summary>
+/// <remarks>
+///     Using this attribute only makes sense if all collection methods are marked with this attribute.
+/// </remarks>
+/// <example>
+///     <code>
+/// public class MyStringCollection : List&lt;string&gt;
+/// {
+///   [CollectionAccess(CollectionAccessType.Read)]
+///   public string GetFirstString()
+///   {
+///     return this.ElementAt(0);
+///   }
+/// }
+/// class Test
+/// {
+///   public void Foo()
+///   {
+///     // Warning: Contents of the collection is never updated
+///     var col = new MyStringCollection();
+///     string x = col.GetFirstString();
+///   }
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)]
+public sealed class CollectionAccessAttribute : Attribute
+{
+    public CollectionAccessAttribute(CollectionAccessType collectionAccessType) =>
+        CollectionAccessType = collectionAccessType;
+
+    public CollectionAccessType CollectionAccessType { get; }
+}
+
+/// <summary>
+///     Provides a value for the <see cref="CollectionAccessAttribute" /> to define
+///     how the collection method invocation affects the contents of the collection.
+/// </summary>
+[Flags]
+public enum CollectionAccessType
+{
+    /// <summary>Method does not use or modify content of the collection.</summary>
+    None = 0,
+
+    /// <summary>Method only reads content of the collection but does not modify it.</summary>
+    Read = 1,
+
+    /// <summary>Method can change content of the collection but does not add new elements.</summary>
+    ModifyExistingContent = 2,
+
+    /// <summary>Method can add new elements to the collection.</summary>
+    UpdatedContent = ModifyExistingContent | 4
+}
+
+/// <summary>
+///     Indicates that the marked method is assertion method, i.e. it halts the control flow if
+///     one of the conditions is satisfied. To set the condition, mark one of the parameters with
+///     <see cref="AssertionConditionAttribute" /> attribute.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class AssertionMethodAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates the condition parameter of the assertion method. The method itself should be
+///     marked by <see cref="AssertionMethodAttribute" /> attribute. The mandatory argument of
+///     the attribute is the assertion type.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter)]
+public sealed class AssertionConditionAttribute : Attribute
+{
+    public AssertionConditionAttribute(AssertionConditionType conditionType) => ConditionType = conditionType;
+
+    public AssertionConditionType ConditionType { get; }
+}
+
+/// <summary>
+///     Specifies assertion type. If the assertion method argument satisfies the condition,
+///     then the execution continues. Otherwise, execution is assumed to be halted.
+/// </summary>
+public enum AssertionConditionType
+{
+    /// <summary>Marked parameter should be evaluated to true.</summary>
+    IS_TRUE = 0,
+
+    /// <summary>Marked parameter should be evaluated to false.</summary>
+    IS_FALSE = 1,
+
+    /// <summary>Marked parameter should be evaluated to null value.</summary>
+    IS_NULL = 2,
+
+    /// <summary>Marked parameter should be evaluated to not null value.</summary>
+    IS_NOT_NULL = 3
+}
+
+/// <summary>
+///     Indicates that the marked method unconditionally terminates control flow execution.
+///     For example, it could unconditionally throw exception.
+/// </summary>
+[Obsolete("Use [ContractAnnotation('=> halt')] instead")]
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class TerminatesProgramAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select,
+///     .Where). This annotation allows inference of [InstantHandle] annotation for parameters
+///     of delegate type by analyzing LINQ method chains.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class LinqTunnelAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that IEnumerable passed as a parameter is not enumerated.
+///     Use this annotation to suppress the 'Possible multiple enumeration of IEnumerable' inspection.
+/// </summary>
+/// <example>
+///     <code>
+/// static void ThrowIfNull&lt;T&gt;([NoEnumeration] T v, string n) where T : class
+/// {
+///   // custom check for null but no enumeration
+/// }
+/// 
+/// void Foo(IEnumerable&lt;string&gt; values)
+/// {
+///   ThrowIfNull(values, nameof(values));
+///   var x = values.ToList(); // No warnings about multiple enumeration
+/// }
+/// </code>
+/// </example>
+[AttributeUsage(AttributeTargets.Parameter)]
+public sealed class NoEnumerationAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Indicates that the marked parameter is a regular expression pattern.
+/// </summary>
+[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class RegexPatternAttribute : Attribute
+{
+}
+
+/// <summary>
+///     Prevents the Member Reordering feature from tossing members of the marked class.
+/// </summary>
+/// <remarks>
+///     The attribute must be mentioned in your member reordering patterns.
+/// </remarks>
+[AttributeUsage(
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.Enum)]
+public sealed class NoReorderAttribute : Attribute
+{
+}
+
+/// <summary>
+///     XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be treated
+///     as <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolve.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public sealed class XamlItemsControlAttribute : Attribute
+{
+}
+
+/// <summary>
+///     XAML attribute. Indicates the property of some <c>BindingBase</c>-derived type, that
+///     is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
+///     enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
+/// </summary>
+/// <remarks>
+///     Property should have the tree ancestor of the <c>ItemsControl</c> type or
+///     marked with the <see cref="XamlItemsControlAttribute" /> attribute.
+/// </remarks>
+[AttributeUsage(AttributeTargets.Property)]
+public sealed class XamlItemBindingOfItemsControlAttribute : Attribute
+{
+}
+
+/// <summary>
+///     XAML attribute. Indicates the property of some <c>Style</c>-derived type, that
+///     is used to style items of <c>ItemsControl</c>-derived type. This annotation will
+///     enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
+/// </summary>
+/// <remarks>
+///     Property should have the tree ancestor of the <c>ItemsControl</c> type or
+///     marked with the <see cref="XamlItemsControlAttribute" /> attribute.
+/// </remarks>
+[AttributeUsage(AttributeTargets.Property)]
+public sealed class XamlItemStyleOfItemsControlAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+public sealed class AspChildControlTypeAttribute : Attribute
+{
+    public AspChildControlTypeAttribute(
+        [NotNull]
+        string tagName,
+        [NotNull]
+        Type controlType)
+    {
+        TagName = tagName;
+        ControlType = controlType;
+    }
+
+    [NotNull]
+    public string TagName { get; }
+
+    [NotNull]
+    public Type ControlType { get; }
+}
+
+[AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
+public sealed class AspDataFieldAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)]
+public sealed class AspDataFieldsAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Property)]
+public sealed class AspMethodPropertyAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+public sealed class AspRequiredAttributeAttribute : Attribute
+{
+    public AspRequiredAttributeAttribute(
+        [NotNull]
+        string attribute) => Attribute = attribute;
+
+    [NotNull]
+    public string Attribute { get; }
+}
+
+[AttributeUsage(AttributeTargets.Property)]
+public sealed class AspTypePropertyAttribute : Attribute
+{
+    public AspTypePropertyAttribute(bool createConstructorReferences) =>
+        CreateConstructorReferences = createConstructorReferences;
+
+    public bool CreateConstructorReferences { get; }
+}
+
+[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+public sealed class RazorImportNamespaceAttribute : Attribute
+{
+    public RazorImportNamespaceAttribute(
+        [NotNull]
+        string name) => Name = name;
+
+    [NotNull]
+    public string Name { get; }
+}
+
+[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+public sealed class RazorInjectionAttribute : Attribute
+{
+    public RazorInjectionAttribute(
+        [NotNull]
+        string type,
+        [NotNull]
+        string fieldName)
+    {
+        Type = type;
+        FieldName = fieldName;
+    }
+
+    [NotNull]
+    public string Type { get; }
+
+    [NotNull]
+    public string FieldName { get; }
+}
+
+[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+public sealed class RazorDirectiveAttribute : Attribute
+{
+    public RazorDirectiveAttribute(
+        [NotNull]
+        string directive) => Directive = directive;
+
+    [NotNull]
+    public string Directive { get; }
+}
+
+[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+public sealed class RazorPageBaseTypeAttribute : Attribute
+{
+    public RazorPageBaseTypeAttribute(
+        [NotNull]
+        string baseType) => BaseType = baseType;
+
+    public RazorPageBaseTypeAttribute(
+        [NotNull]
+        string baseType,
+        string pageName)
+    {
+        BaseType = baseType;
+        PageName = pageName;
+    }
+
+    [NotNull]
+    public string BaseType { get; }
+
+    [CanBeNull]
+    public string PageName { get; }
+}
+
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class RazorHelperCommonAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Property)]
+public sealed class RazorLayoutAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class RazorWriteLiteralMethodAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class RazorWriteMethodAttribute : Attribute
+{
+}
+
+[AttributeUsage(AttributeTargets.Parameter)]
+public sealed class RazorWriteMethodParameterAttribute : Attribute
+{
+}
\ No newline at end of file
diff --git a/ErsatzTV/Serialization/CustomContractResolver.cs b/ErsatzTV/Serialization/CustomContractResolver.cs
index f2141e374..1b7811378 100644
--- a/ErsatzTV/Serialization/CustomContractResolver.cs
+++ b/ErsatzTV/Serialization/CustomContractResolver.cs
@@ -1,9 +1,8 @@
 using Newtonsoft.Json.Serialization;
 
-namespace ErsatzTV.Serialization
+namespace ErsatzTV.Serialization;
+
+public class CustomContractResolver : DefaultContractResolver
 {
-    public class CustomContractResolver : DefaultContractResolver
-    {
-        public CustomContractResolver() => NamingStrategy = new CustomNamingStrategy();
-    }
-}
+    public CustomContractResolver() => NamingStrategy = new CustomNamingStrategy();
+}
\ No newline at end of file
diff --git a/ErsatzTV/Serialization/CustomNamingStrategy.cs b/ErsatzTV/Serialization/CustomNamingStrategy.cs
index a38495baa..60503be1d 100644
--- a/ErsatzTV/Serialization/CustomNamingStrategy.cs
+++ b/ErsatzTV/Serialization/CustomNamingStrategy.cs
@@ -1,18 +1,16 @@
-using System;
-using Newtonsoft.Json.Serialization;
+using Newtonsoft.Json.Serialization;
 
-namespace ErsatzTV.Serialization
+namespace ErsatzTV.Serialization;
+
+public class CustomNamingStrategy : CamelCaseNamingStrategy
 {
-    public class CustomNamingStrategy : CamelCaseNamingStrategy
+    protected override string ResolvePropertyName(string name)
     {
-        protected override string ResolvePropertyName(string name)
+        if (name.Equals("FFmpegProfileId", StringComparison.OrdinalIgnoreCase))
         {
-            if (name.Equals("FFmpegProfileId", StringComparison.OrdinalIgnoreCase))
-            {
-                return "ffmpegProfileId";
-            }
-
-            return base.ResolvePropertyName(name);
+            return "ffmpegProfileId";
         }
+
+        return base.ResolvePropertyName(name);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/EmbyService.cs b/ErsatzTV/Services/EmbyService.cs
index 113d04daa..7dcb3f707 100644
--- a/ErsatzTV/Services/EmbyService.cs
+++ b/ErsatzTV/Services/EmbyService.cs
@@ -1,159 +1,147 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Application;
-using ErsatzTV.Application.Emby.Commands;
+using ErsatzTV.Application.Emby;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 using MediatR;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Services
+namespace ErsatzTV.Services;
+
+public class EmbyService : BackgroundService
 {
-    public class EmbyService : BackgroundService
+    private readonly ChannelReader<IEmbyBackgroundServiceRequest> _channel;
+    private readonly ILogger<EmbyService> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public EmbyService(
+        ChannelReader<IEmbyBackgroundServiceRequest> channel,
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<EmbyService> logger)
     {
-        private readonly ChannelReader<IEmbyBackgroundServiceRequest> _channel;
-        private readonly ILogger<EmbyService> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
+        _channel = channel;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
+    }
 
-        public EmbyService(
-            ChannelReader<IEmbyBackgroundServiceRequest> channel,
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<EmbyService> logger)
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    {
+        if (!File.Exists(FileSystemLayout.EmbySecretsPath))
         {
-            _channel = channel;
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
+            await File.WriteAllTextAsync(FileSystemLayout.EmbySecretsPath, "{}", cancellationToken);
         }
 
-        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+        _logger.LogInformation(
+            "Emby service started; secrets are at {EmbySecretsPath}",
+            FileSystemLayout.EmbySecretsPath);
+
+        // synchronize sources on startup
+        await SynchronizeSources(new SynchronizeEmbyMediaSources(), cancellationToken);
+
+        await foreach (IEmbyBackgroundServiceRequest request in _channel.ReadAllAsync(cancellationToken))
         {
-            if (!File.Exists(FileSystemLayout.EmbySecretsPath))
+            try
             {
-                await File.WriteAllTextAsync(FileSystemLayout.EmbySecretsPath, "{}", cancellationToken);
+                Task requestTask;
+                switch (request)
+                {
+                    case SynchronizeEmbyMediaSources synchronizeEmbyMediaSources:
+                        requestTask = SynchronizeSources(synchronizeEmbyMediaSources, cancellationToken);
+                        break;
+                    // case SynchronizeEmbyAdminUserId synchronizeEmbyAdminUserId:
+                    //     requestTask = SynchronizeAdminUserId(synchronizeEmbyAdminUserId, cancellationToken);
+                    //     break;
+                    case SynchronizeEmbyLibraries synchronizeEmbyLibraries:
+                        requestTask = SynchronizeLibraries(synchronizeEmbyLibraries, cancellationToken);
+                        break;
+                    case ISynchronizeEmbyLibraryById synchronizeEmbyLibraryById:
+                        requestTask = SynchronizeEmbyLibrary(synchronizeEmbyLibraryById, cancellationToken);
+                        break;
+                    default:
+                        throw new NotSupportedException($"Unsupported request type: {request.GetType().Name}");
+                }
+
+                await requestTask;
             }
-
-            _logger.LogInformation(
-                "Emby service started; secrets are at {EmbySecretsPath}",
-                FileSystemLayout.EmbySecretsPath);
-
-            // synchronize sources on startup
-            await SynchronizeSources(new SynchronizeEmbyMediaSources(), cancellationToken);
-
-            await foreach (IEmbyBackgroundServiceRequest request in _channel.ReadAllAsync(cancellationToken))
+            catch (Exception ex)
             {
-                try
-                {
-                    Task requestTask;
-                    switch (request)
-                    {
-                        case SynchronizeEmbyMediaSources synchronizeEmbyMediaSources:
-                            requestTask = SynchronizeSources(synchronizeEmbyMediaSources, cancellationToken);
-                            break;
-                        // case SynchronizeEmbyAdminUserId synchronizeEmbyAdminUserId:
-                        //     requestTask = SynchronizeAdminUserId(synchronizeEmbyAdminUserId, cancellationToken);
-                        //     break;
-                        case SynchronizeEmbyLibraries synchronizeEmbyLibraries:
-                            requestTask = SynchronizeLibraries(synchronizeEmbyLibraries, cancellationToken);
-                            break;
-                        case ISynchronizeEmbyLibraryById synchronizeEmbyLibraryById:
-                            requestTask = SynchronizeEmbyLibrary(synchronizeEmbyLibraryById, cancellationToken);
-                            break;
-                        default:
-                            throw new NotSupportedException($"Unsupported request type: {request.GetType().Name}");
-                    }
-
-                    await requestTask;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to process Emby background service request");
-                }
+                _logger.LogWarning(ex, "Failed to process Emby background service request");
             }
         }
-
-        private async Task SynchronizeSources(
-            SynchronizeEmbyMediaSources request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, List<EmbyMediaSource>> result = await mediator.Send(request, cancellationToken);
-            result.Match(
-                sources =>
-                {
-                    if (sources.Any())
-                    {
-                        _logger.LogInformation("Successfully synchronized emby media sources");
-                    }
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Unable to synchronize emby media sources: {Error}",
-                        error.Value);
-                });
-        }
-
-        private async Task SynchronizeLibraries(
-            SynchronizeEmbyLibraries request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
-            result.BiIter(
-                _ => _logger.LogInformation(
-                    "Successfully synchronized Emby libraries for source {MediaSourceId}",
-                    request.EmbyMediaSourceId),
-                error => _logger.LogWarning(
-                    "Unable to synchronize Emby libraries for source {MediaSourceId}: {Error}",
-                    request.EmbyMediaSourceId,
-                    error.Value));
-        }
-
-        // private async Task SynchronizeAdminUserId(
-        //     SynchronizeEmbyAdminUserId request,
-        //     CancellationToken cancellationToken)
-        // {
-        //     using IServiceScope scope = _serviceScopeFactory.CreateScope();
-        //     IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-        //
-        //     Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
-        //     result.BiIter(
-        //         _ => _logger.LogInformation(
-        //             "Successfully synchronized Emby admin user id for source {MediaSourceId}",
-        //             request.EmbyMediaSourceId),
-        //         error => _logger.LogWarning(
-        //             "Unable to synchronize Emby admin user id for source {MediaSourceId}: {Error}",
-        //             request.EmbyMediaSourceId,
-        //             error.Value));
-        // }
-
-        private async Task SynchronizeEmbyLibrary(
-            ISynchronizeEmbyLibraryById request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, string> result = await mediator.Send(request, cancellationToken);
-            result.BiIter(
-                name => _logger.LogDebug("Done synchronizing emby library {Name}", name),
-                error => _logger.LogWarning(
-                    "Unable to synchronize emby library {LibraryId}: {Error}",
-                    request.EmbyLibraryId,
-                    error.Value));
-        }
     }
-}
+
+    private async Task SynchronizeSources(
+        SynchronizeEmbyMediaSources request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, List<EmbyMediaSource>> result = await mediator.Send(request, cancellationToken);
+        result.Match(
+            sources =>
+            {
+                if (sources.Any())
+                {
+                    _logger.LogInformation("Successfully synchronized emby media sources");
+                }
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Unable to synchronize emby media sources: {Error}",
+                    error.Value);
+            });
+    }
+
+    private async Task SynchronizeLibraries(
+        SynchronizeEmbyLibraries request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
+        result.BiIter(
+            _ => _logger.LogInformation(
+                "Successfully synchronized Emby libraries for source {MediaSourceId}",
+                request.EmbyMediaSourceId),
+            error => _logger.LogWarning(
+                "Unable to synchronize Emby libraries for source {MediaSourceId}: {Error}",
+                request.EmbyMediaSourceId,
+                error.Value));
+    }
+
+    // private async Task SynchronizeAdminUserId(
+    //     SynchronizeEmbyAdminUserId request,
+    //     CancellationToken cancellationToken)
+    // {
+    //     using IServiceScope scope = _serviceScopeFactory.CreateScope();
+    //     IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+    //
+    //     Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
+    //     result.BiIter(
+    //         _ => _logger.LogInformation(
+    //             "Successfully synchronized Emby admin user id for source {MediaSourceId}",
+    //             request.EmbyMediaSourceId),
+    //         error => _logger.LogWarning(
+    //             "Unable to synchronize Emby admin user id for source {MediaSourceId}: {Error}",
+    //             request.EmbyMediaSourceId,
+    //             error.Value));
+    // }
+
+    private async Task SynchronizeEmbyLibrary(
+        ISynchronizeEmbyLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, string> result = await mediator.Send(request, cancellationToken);
+        result.BiIter(
+            name => _logger.LogDebug("Done synchronizing emby library {Name}", name),
+            error => _logger.LogWarning(
+                "Unable to synchronize emby library {LibraryId}: {Error}",
+                request.EmbyLibraryId,
+                error.Value));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/FFmpegLocatorService.cs b/ErsatzTV/Services/FFmpegLocatorService.cs
index fd0e814dd..3c839af02 100644
--- a/ErsatzTV/Services/FFmpegLocatorService.cs
+++ b/ErsatzTV/Services/FFmpegLocatorService.cs
@@ -1,46 +1,39 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.FFmpeg;
-using LanguageExt;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Services
+namespace ErsatzTV.Services;
+
+public class FFmpegLocatorService : IHostedService
 {
-    public class FFmpegLocatorService : IHostedService
+    private readonly ILogger<FFmpegLocatorService> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public FFmpegLocatorService(
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<FFmpegLocatorService> logger)
     {
-        private readonly ILogger<FFmpegLocatorService> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
-
-        public FFmpegLocatorService(
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<FFmpegLocatorService> logger)
-        {
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
-        }
-
-        public async Task StartAsync(CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IFFmpegLocator ffmpegLocator = scope.ServiceProvider.GetRequiredService<IFFmpegLocator>();
-
-            // check for ffmpeg and ffprobe in the last known/configured location
-            // otherwise search using which/where and save any located executables
-            Option<string> maybeFFmpegPath = await ffmpegLocator.ValidatePath("ffmpeg", ConfigElementKey.FFmpegPath);
-            maybeFFmpegPath.Match(
-                path => _logger.LogInformation("Located ffmpeg at {Path}", path),
-                () => _logger.LogWarning("Failed to locate ffmpeg executable"));
-
-            Option<string> maybeFFprobePath =
-                await ffmpegLocator.ValidatePath("ffprobe", ConfigElementKey.FFprobePath);
-            maybeFFprobePath.Match(
-                path => _logger.LogInformation("Located ffprobe at {Path}", path),
-                () => _logger.LogWarning("Failed to locate ffprobe executable"));
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
     }
-}
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IFFmpegLocator ffmpegLocator = scope.ServiceProvider.GetRequiredService<IFFmpegLocator>();
+
+        // check for ffmpeg and ffprobe in the last known/configured location
+        // otherwise search using which/where and save any located executables
+        Option<string> maybeFFmpegPath = await ffmpegLocator.ValidatePath("ffmpeg", ConfigElementKey.FFmpegPath);
+        maybeFFmpegPath.Match(
+            path => _logger.LogInformation("Located ffmpeg at {Path}", path),
+            () => _logger.LogWarning("Failed to locate ffmpeg executable"));
+
+        Option<string> maybeFFprobePath =
+            await ffmpegLocator.ValidatePath("ffprobe", ConfigElementKey.FFprobePath);
+        maybeFFprobePath.Match(
+            path => _logger.LogInformation("Located ffprobe at {Path}", path),
+            () => _logger.LogWarning("Failed to locate ffprobe executable"));
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/FFmpegWorkerService.cs b/ErsatzTV/Services/FFmpegWorkerService.cs
index deb407779..c66458f62 100644
--- a/ErsatzTV/Services/FFmpegWorkerService.cs
+++ b/ErsatzTV/Services/FFmpegWorkerService.cs
@@ -1,64 +1,55 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Application;
-using ErsatzTV.Application.Streaming.Commands;
+using ErsatzTV.Application.Streaming;
 using ErsatzTV.Core.Interfaces.FFmpeg;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using static LanguageExt.Prelude;
 
-namespace ErsatzTV.Services
+namespace ErsatzTV.Services;
+
+public class FFmpegWorkerService : BackgroundService
 {
-    public class FFmpegWorkerService : BackgroundService
+    private readonly ChannelReader<IFFmpegWorkerRequest> _channel;
+    private readonly ILogger<FFmpegWorkerService> _logger;
+    private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public FFmpegWorkerService(
+        ChannelReader<IFFmpegWorkerRequest> channel,
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<FFmpegWorkerService> logger,
+        IFFmpegSegmenterService ffmpegSegmenterService)
     {
-        private readonly ChannelReader<IFFmpegWorkerRequest> _channel;
-        private readonly ILogger<FFmpegWorkerService> _logger;
-        private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
+        _channel = channel;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
+        _ffmpegSegmenterService = ffmpegSegmenterService;
+    }
 
-        public FFmpegWorkerService(
-            ChannelReader<IFFmpegWorkerRequest> channel,
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<FFmpegWorkerService> logger,
-            IFFmpegSegmenterService ffmpegSegmenterService)
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("FFmpeg worker service started");
+
+        await foreach (IFFmpegWorkerRequest request in _channel.ReadAllAsync(cancellationToken))
         {
-            _channel = channel;
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
-            _ffmpegSegmenterService = ffmpegSegmenterService;
-        }
-
-        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
-        {
-            _logger.LogInformation("FFmpeg worker service started");
-
-            await foreach (IFFmpegWorkerRequest request in _channel.ReadAllAsync(cancellationToken))
+            try
             {
-                try
-                {
-                    using IServiceScope scope = _serviceScopeFactory.CreateScope();
-                    // IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+                using IServiceScope scope = _serviceScopeFactory.CreateScope();
+                // IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
 
-                    switch (request)
-                    {
-                        case TouchFFmpegSession touchFFmpegSession:
-                            foreach (DirectoryInfo parent in Optional(Directory.GetParent(touchFFmpegSession.Path)))
-                            {
-                                _ffmpegSegmenterService.TouchChannel(parent.Name);
-                            }
-
-                            break;
-                    }
-                }
-                catch (Exception ex)
+                switch (request)
                 {
-                     _logger.LogWarning(ex, "Failed to handle ffmpeg worker request");
+                    case TouchFFmpegSession touchFFmpegSession:
+                        foreach (DirectoryInfo parent in Optional(Directory.GetParent(touchFFmpegSession.Path)))
+                        {
+                            _ffmpegSegmenterService.TouchChannel(parent.Name);
+                        }
+
+                        break;
                 }
             }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to handle ffmpeg worker request");
+            }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/JellyfinService.cs b/ErsatzTV/Services/JellyfinService.cs
index 62f6a3fdd..5d5b686ff 100644
--- a/ErsatzTV/Services/JellyfinService.cs
+++ b/ErsatzTV/Services/JellyfinService.cs
@@ -1,159 +1,147 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Application;
-using ErsatzTV.Application.Jellyfin.Commands;
+using ErsatzTV.Application.Jellyfin;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 using MediatR;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Services
+namespace ErsatzTV.Services;
+
+public class JellyfinService : BackgroundService
 {
-    public class JellyfinService : BackgroundService
+    private readonly ChannelReader<IJellyfinBackgroundServiceRequest> _channel;
+    private readonly ILogger<JellyfinService> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public JellyfinService(
+        ChannelReader<IJellyfinBackgroundServiceRequest> channel,
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<JellyfinService> logger)
     {
-        private readonly ChannelReader<IJellyfinBackgroundServiceRequest> _channel;
-        private readonly ILogger<JellyfinService> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
+        _channel = channel;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
+    }
 
-        public JellyfinService(
-            ChannelReader<IJellyfinBackgroundServiceRequest> channel,
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<JellyfinService> logger)
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    {
+        if (!File.Exists(FileSystemLayout.JellyfinSecretsPath))
         {
-            _channel = channel;
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
+            await File.WriteAllTextAsync(FileSystemLayout.JellyfinSecretsPath, "{}", cancellationToken);
         }
 
-        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+        _logger.LogInformation(
+            "Jellyfin service started; secrets are at {JellyfinSecretsPath}",
+            FileSystemLayout.JellyfinSecretsPath);
+
+        // synchronize sources on startup
+        await SynchronizeSources(new SynchronizeJellyfinMediaSources(), cancellationToken);
+
+        await foreach (IJellyfinBackgroundServiceRequest request in _channel.ReadAllAsync(cancellationToken))
         {
-            if (!File.Exists(FileSystemLayout.JellyfinSecretsPath))
+            try
             {
-                await File.WriteAllTextAsync(FileSystemLayout.JellyfinSecretsPath, "{}", cancellationToken);
+                Task requestTask;
+                switch (request)
+                {
+                    case SynchronizeJellyfinMediaSources synchronizeJellyfinMediaSources:
+                        requestTask = SynchronizeSources(synchronizeJellyfinMediaSources, cancellationToken);
+                        break;
+                    case SynchronizeJellyfinAdminUserId synchronizeJellyfinAdminUserId:
+                        requestTask = SynchronizeAdminUserId(synchronizeJellyfinAdminUserId, cancellationToken);
+                        break;
+                    case SynchronizeJellyfinLibraries synchronizeJellyfinLibraries:
+                        requestTask = SynchronizeLibraries(synchronizeJellyfinLibraries, cancellationToken);
+                        break;
+                    case ISynchronizeJellyfinLibraryById synchronizeJellyfinLibraryById:
+                        requestTask = SynchronizeJellyfinLibrary(synchronizeJellyfinLibraryById, cancellationToken);
+                        break;
+                    default:
+                        throw new NotSupportedException($"Unsupported request type: {request.GetType().Name}");
+                }
+
+                await requestTask;
             }
-
-            _logger.LogInformation(
-                "Jellyfin service started; secrets are at {JellyfinSecretsPath}",
-                FileSystemLayout.JellyfinSecretsPath);
-
-            // synchronize sources on startup
-            await SynchronizeSources(new SynchronizeJellyfinMediaSources(), cancellationToken);
-
-            await foreach (IJellyfinBackgroundServiceRequest request in _channel.ReadAllAsync(cancellationToken))
+            catch (Exception ex)
             {
-                try
-                {
-                    Task requestTask;
-                    switch (request)
-                    {
-                        case SynchronizeJellyfinMediaSources synchronizeJellyfinMediaSources:
-                            requestTask = SynchronizeSources(synchronizeJellyfinMediaSources, cancellationToken);
-                            break;
-                        case SynchronizeJellyfinAdminUserId synchronizeJellyfinAdminUserId:
-                            requestTask = SynchronizeAdminUserId(synchronizeJellyfinAdminUserId, cancellationToken);
-                            break;
-                        case SynchronizeJellyfinLibraries synchronizeJellyfinLibraries:
-                            requestTask = SynchronizeLibraries(synchronizeJellyfinLibraries, cancellationToken);
-                            break;
-                        case ISynchronizeJellyfinLibraryById synchronizeJellyfinLibraryById:
-                            requestTask = SynchronizeJellyfinLibrary(synchronizeJellyfinLibraryById, cancellationToken);
-                            break;
-                        default:
-                            throw new NotSupportedException($"Unsupported request type: {request.GetType().Name}");
-                    }
-
-                    await requestTask;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to process Jellyfin background service request");
-                }
+                _logger.LogWarning(ex, "Failed to process Jellyfin background service request");
             }
         }
-
-        private async Task SynchronizeSources(
-            SynchronizeJellyfinMediaSources request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, List<JellyfinMediaSource>> result = await mediator.Send(request, cancellationToken);
-            result.Match(
-                sources =>
-                {
-                    if (sources.Any())
-                    {
-                        _logger.LogInformation("Successfully synchronized jellyfin media sources");
-                    }
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Unable to synchronize jellyfin media sources: {Error}",
-                        error.Value);
-                });
-        }
-
-        private async Task SynchronizeLibraries(
-            SynchronizeJellyfinLibraries request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
-            result.BiIter(
-                _ => _logger.LogInformation(
-                    "Successfully synchronized Jellyfin libraries for source {MediaSourceId}",
-                    request.JellyfinMediaSourceId),
-                error => _logger.LogWarning(
-                    "Unable to synchronize Jellyfin libraries for source {MediaSourceId}: {Error}",
-                    request.JellyfinMediaSourceId,
-                    error.Value));
-        }
-
-        private async Task SynchronizeAdminUserId(
-            SynchronizeJellyfinAdminUserId request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
-            result.BiIter(
-                _ => _logger.LogInformation(
-                    "Successfully synchronized Jellyfin admin user id for source {MediaSourceId}",
-                    request.JellyfinMediaSourceId),
-                error => _logger.LogWarning(
-                    "Unable to synchronize Jellyfin admin user id for source {MediaSourceId}: {Error}",
-                    request.JellyfinMediaSourceId,
-                    error.Value));
-        }
-
-        private async Task SynchronizeJellyfinLibrary(
-            ISynchronizeJellyfinLibraryById request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, string> result = await mediator.Send(request, cancellationToken);
-            result.BiIter(
-                name => _logger.LogDebug("Done synchronizing jellyfin library {Name}", name),
-                error => _logger.LogWarning(
-                    "Unable to synchronize jellyfin library {LibraryId}: {Error}",
-                    request.JellyfinLibraryId,
-                    error.Value));
-        }
     }
-}
+
+    private async Task SynchronizeSources(
+        SynchronizeJellyfinMediaSources request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, List<JellyfinMediaSource>> result = await mediator.Send(request, cancellationToken);
+        result.Match(
+            sources =>
+            {
+                if (sources.Any())
+                {
+                    _logger.LogInformation("Successfully synchronized jellyfin media sources");
+                }
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Unable to synchronize jellyfin media sources: {Error}",
+                    error.Value);
+            });
+    }
+
+    private async Task SynchronizeLibraries(
+        SynchronizeJellyfinLibraries request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
+        result.BiIter(
+            _ => _logger.LogInformation(
+                "Successfully synchronized Jellyfin libraries for source {MediaSourceId}",
+                request.JellyfinMediaSourceId),
+            error => _logger.LogWarning(
+                "Unable to synchronize Jellyfin libraries for source {MediaSourceId}: {Error}",
+                request.JellyfinMediaSourceId,
+                error.Value));
+    }
+
+    private async Task SynchronizeAdminUserId(
+        SynchronizeJellyfinAdminUserId request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
+        result.BiIter(
+            _ => _logger.LogInformation(
+                "Successfully synchronized Jellyfin admin user id for source {MediaSourceId}",
+                request.JellyfinMediaSourceId),
+            error => _logger.LogWarning(
+                "Unable to synchronize Jellyfin admin user id for source {MediaSourceId}: {Error}",
+                request.JellyfinMediaSourceId,
+                error.Value));
+    }
+
+    private async Task SynchronizeJellyfinLibrary(
+        ISynchronizeJellyfinLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, string> result = await mediator.Send(request, cancellationToken);
+        result.BiIter(
+            name => _logger.LogDebug("Done synchronizing jellyfin library {Name}", name),
+            error => _logger.LogWarning(
+                "Unable to synchronize jellyfin library {LibraryId}: {Error}",
+                request.JellyfinLibraryId,
+                error.Value));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/PlexService.cs b/ErsatzTV/Services/PlexService.cs
index ceefcbab4..41dda9f60 100644
--- a/ErsatzTV/Services/PlexService.cs
+++ b/ErsatzTV/Services/PlexService.cs
@@ -1,156 +1,144 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Application;
-using ErsatzTV.Application.Plex.Commands;
+using ErsatzTV.Application.Plex;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
-using LanguageExt;
 using MediatR;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Services
+namespace ErsatzTV.Services;
+
+public class PlexService : BackgroundService
 {
-    public class PlexService : BackgroundService
+    private readonly ChannelReader<IPlexBackgroundServiceRequest> _channel;
+    private readonly ILogger<PlexService> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public PlexService(
+        ChannelReader<IPlexBackgroundServiceRequest> channel,
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<PlexService> logger)
     {
-        private readonly ChannelReader<IPlexBackgroundServiceRequest> _channel;
-        private readonly ILogger<PlexService> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
+        _channel = channel;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
+    }
 
-        public PlexService(
-            ChannelReader<IPlexBackgroundServiceRequest> channel,
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<PlexService> logger)
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    {
+        if (!File.Exists(FileSystemLayout.PlexSecretsPath))
         {
-            _channel = channel;
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
+            await File.WriteAllTextAsync(FileSystemLayout.PlexSecretsPath, "{}", cancellationToken);
         }
 
-        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+        _logger.LogInformation(
+            "Plex service started; secrets are at {PlexSecretsPath}",
+            FileSystemLayout.PlexSecretsPath);
+
+        // synchronize sources on startup
+        await SynchronizeSources(new SynchronizePlexMediaSources(), cancellationToken);
+
+        await foreach (IPlexBackgroundServiceRequest request in _channel.ReadAllAsync(cancellationToken))
         {
-            if (!File.Exists(FileSystemLayout.PlexSecretsPath))
+            try
             {
-                await File.WriteAllTextAsync(FileSystemLayout.PlexSecretsPath, "{}", cancellationToken);
+                Task requestTask;
+                switch (request)
+                {
+                    case TryCompletePlexPinFlow pinRequest:
+                        requestTask = CompletePinFlow(pinRequest, cancellationToken);
+                        break;
+                    case SynchronizePlexMediaSources sourcesRequest:
+                        requestTask = SynchronizeSources(sourcesRequest, cancellationToken);
+                        break;
+                    case SynchronizePlexLibraries synchronizePlexLibrariesRequest:
+                        requestTask = SynchronizeLibraries(synchronizePlexLibrariesRequest, cancellationToken);
+                        break;
+                    case ISynchronizePlexLibraryById synchronizePlexLibraryById:
+                        requestTask = SynchronizePlexLibrary(synchronizePlexLibraryById, cancellationToken);
+                        break;
+                    default:
+                        throw new NotSupportedException($"Unsupported request type: {request.GetType().Name}");
+                }
+
+                await requestTask;
             }
-
-            _logger.LogInformation(
-                "Plex service started; secrets are at {PlexSecretsPath}",
-                FileSystemLayout.PlexSecretsPath);
-
-            // synchronize sources on startup
-            await SynchronizeSources(new SynchronizePlexMediaSources(), cancellationToken);
-
-            await foreach (IPlexBackgroundServiceRequest request in _channel.ReadAllAsync(cancellationToken))
+            catch (Exception ex)
             {
-                try
-                {
-                    Task requestTask;
-                    switch (request)
-                    {
-                        case TryCompletePlexPinFlow pinRequest:
-                            requestTask = CompletePinFlow(pinRequest, cancellationToken);
-                            break;
-                        case SynchronizePlexMediaSources sourcesRequest:
-                            requestTask = SynchronizeSources(sourcesRequest, cancellationToken);
-                            break;
-                        case SynchronizePlexLibraries synchronizePlexLibrariesRequest:
-                            requestTask = SynchronizeLibraries(synchronizePlexLibrariesRequest, cancellationToken);
-                            break;
-                        case ISynchronizePlexLibraryById synchronizePlexLibraryById:
-                            requestTask = SynchronizePlexLibrary(synchronizePlexLibraryById, cancellationToken);
-                            break;
-                        default:
-                            throw new NotSupportedException($"Unsupported request type: {request.GetType().Name}");
-                    }
-
-                    await requestTask;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "Failed to process plex background service request");
-                }
+                _logger.LogWarning(ex, "Failed to process plex background service request");
             }
         }
-
-        private async Task<List<PlexMediaSource>> SynchronizeSources(
-            SynchronizePlexMediaSources request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, List<PlexMediaSource>> result = await mediator.Send(request, cancellationToken);
-            return result.Match(
-                sources =>
-                {
-                    if (sources.Any())
-                    {
-                        _logger.LogInformation("Successfully synchronized plex media sources");
-                    }
-
-                    return sources;
-                },
-                error =>
-                {
-                    _logger.LogWarning(
-                        "Unable to synchronize plex media sources: {Error}",
-                        error.Value);
-                    return new List<PlexMediaSource>();
-                });
-        }
-
-        private async Task CompletePinFlow(
-            TryCompletePlexPinFlow request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, bool> result = await mediator.Send(request, cancellationToken);
-            result.BiIter(
-                success => _logger.LogInformation(
-                    success ? "Successfully authenticated with plex" : "Plex authentication timeout"),
-                error => _logger.LogWarning("Unable to poll plex token: {Error}", error.Value));
-        }
-
-        private async Task SynchronizeLibraries(SynchronizePlexLibraries request, CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
-            result.BiIter(
-                _ => _logger.LogInformation(
-                    "Successfully synchronized plex libraries for source {MediaSourceId}",
-                    request.PlexMediaSourceId),
-                error => _logger.LogWarning(
-                    "Unable to synchronize plex libraries for source {MediaSourceId}: {Error}",
-                    request.PlexMediaSourceId,
-                    error.Value));
-        }
-
-        private async Task SynchronizePlexLibrary(
-            ISynchronizePlexLibraryById request,
-            CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
-
-            Either<BaseError, string> result = await mediator.Send(request, cancellationToken);
-            result.BiIter(
-                name => _logger.LogDebug("Done synchronizing plex library {Name}", name),
-                error => _logger.LogWarning(
-                    "Unable to synchronize plex library {LibraryId}: {Error}",
-                    request.PlexLibraryId,
-                    error.Value));
-        }
     }
-}
+
+    private async Task<List<PlexMediaSource>> SynchronizeSources(
+        SynchronizePlexMediaSources request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, List<PlexMediaSource>> result = await mediator.Send(request, cancellationToken);
+        return result.Match(
+            sources =>
+            {
+                if (sources.Any())
+                {
+                    _logger.LogInformation("Successfully synchronized plex media sources");
+                }
+
+                return sources;
+            },
+            error =>
+            {
+                _logger.LogWarning(
+                    "Unable to synchronize plex media sources: {Error}",
+                    error.Value);
+                return new List<PlexMediaSource>();
+            });
+    }
+
+    private async Task CompletePinFlow(
+        TryCompletePlexPinFlow request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, bool> result = await mediator.Send(request, cancellationToken);
+        result.BiIter(
+            success => _logger.LogInformation(
+                success ? "Successfully authenticated with plex" : "Plex authentication timeout"),
+            error => _logger.LogWarning("Unable to poll plex token: {Error}", error.Value));
+    }
+
+    private async Task SynchronizeLibraries(SynchronizePlexLibraries request, CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, Unit> result = await mediator.Send(request, cancellationToken);
+        result.BiIter(
+            _ => _logger.LogInformation(
+                "Successfully synchronized plex libraries for source {MediaSourceId}",
+                request.PlexMediaSourceId),
+            error => _logger.LogWarning(
+                "Unable to synchronize plex libraries for source {MediaSourceId}: {Error}",
+                request.PlexMediaSourceId,
+                error.Value));
+    }
+
+    private async Task SynchronizePlexLibrary(
+        ISynchronizePlexLibraryById request,
+        CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+
+        Either<BaseError, string> result = await mediator.Send(request, cancellationToken);
+        result.BiIter(
+            name => _logger.LogDebug("Done synchronizing plex library {Name}", name),
+            error => _logger.LogWarning(
+                "Unable to synchronize plex library {LibraryId}: {Error}",
+                request.PlexLibraryId,
+                error.Value));
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/RunOnce/CacheCleanerService.cs b/ErsatzTV/Services/RunOnce/CacheCleanerService.cs
index c5cbec843..76c57c677 100644
--- a/ErsatzTV/Services/RunOnce/CacheCleanerService.cs
+++ b/ErsatzTV/Services/RunOnce/CacheCleanerService.cs
@@ -1,64 +1,55 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Services.RunOnce
+namespace ErsatzTV.Services.RunOnce;
+
+public class CacheCleanerService : IHostedService
 {
-    public class CacheCleanerService : IHostedService
+    private readonly ILogger<CacheCleanerService> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public CacheCleanerService(
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<CacheCleanerService> logger)
     {
-        private readonly ILogger<CacheCleanerService> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
-
-        public CacheCleanerService(
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<CacheCleanerService> logger)
-        {
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
-        }
-
-        public async Task StartAsync(CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            await using TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
-
-            if (Directory.Exists(FileSystemLayout.LegacyImageCacheFolder))
-            {
-                _logger.LogInformation("Migrating channel logos from legacy image cache folder");
-
-                List<string> logos = await dbContext.Channels
-                    .SelectMany(c => c.Artwork)
-                    .Where(a => a.ArtworkKind == ArtworkKind.Logo)
-                    .Map(a => a.Path)
-                    .ToListAsync(cancellationToken);
-
-                ILocalFileSystem localFileSystem = scope.ServiceProvider.GetRequiredService<ILocalFileSystem>();
-                foreach (string logo in logos)
-                {
-                    string legacyPath = Path.Combine(FileSystemLayout.LegacyImageCacheFolder, logo);
-                    if (File.Exists(legacyPath))
-                    {
-                        string subfolder = logo.Substring(0, 2);
-                        string newPath = Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder, logo);
-                        await localFileSystem.CopyFile(legacyPath, newPath);
-                    }
-                }
-
-                _logger.LogInformation("Deleting legacy image cache folder");
-                Directory.Delete(FileSystemLayout.LegacyImageCacheFolder, true);
-            }
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
     }
-}
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        await using TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
+
+        if (Directory.Exists(FileSystemLayout.LegacyImageCacheFolder))
+        {
+            _logger.LogInformation("Migrating channel logos from legacy image cache folder");
+
+            List<string> logos = await dbContext.Channels
+                .SelectMany(c => c.Artwork)
+                .Where(a => a.ArtworkKind == ArtworkKind.Logo)
+                .Map(a => a.Path)
+                .ToListAsync(cancellationToken);
+
+            ILocalFileSystem localFileSystem = scope.ServiceProvider.GetRequiredService<ILocalFileSystem>();
+            foreach (string logo in logos)
+            {
+                string legacyPath = Path.Combine(FileSystemLayout.LegacyImageCacheFolder, logo);
+                if (File.Exists(legacyPath))
+                {
+                    string subfolder = logo.Substring(0, 2);
+                    string newPath = Path.Combine(FileSystemLayout.LogoCacheFolder, subfolder, logo);
+                    await localFileSystem.CopyFile(legacyPath, newPath);
+                }
+            }
+
+            _logger.LogInformation("Deleting legacy image cache folder");
+            Directory.Delete(FileSystemLayout.LegacyImageCacheFolder, true);
+        }
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/RunOnce/DatabaseMigratorService.cs b/ErsatzTV/Services/RunOnce/DatabaseMigratorService.cs
index 2d3c2ffc6..3334b882d 100644
--- a/ErsatzTV/Services/RunOnce/DatabaseMigratorService.cs
+++ b/ErsatzTV/Services/RunOnce/DatabaseMigratorService.cs
@@ -1,38 +1,32 @@
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Services.RunOnce
+namespace ErsatzTV.Services.RunOnce;
+
+public class DatabaseMigratorService : IHostedService
 {
-    public class DatabaseMigratorService : IHostedService
+    private readonly ILogger<DatabaseMigratorService> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public DatabaseMigratorService(
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<DatabaseMigratorService> logger)
     {
-        private readonly ILogger<DatabaseMigratorService> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
-
-        public DatabaseMigratorService(
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<DatabaseMigratorService> logger)
-        {
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
-        }
-
-        public async Task StartAsync(CancellationToken cancellationToken)
-        {
-            _logger.LogInformation("Applying database migrations");
-
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            await using TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
-            await dbContext.Database.MigrateAsync(cancellationToken);
-            await DbInitializer.Initialize(dbContext, cancellationToken);
-
-            _logger.LogInformation("Done applying database migrations");
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
     }
-}
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Applying database migrations");
+
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        await using TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
+        await dbContext.Database.MigrateAsync(cancellationToken);
+        await DbInitializer.Initialize(dbContext, cancellationToken);
+
+        _logger.LogInformation("Done applying database migrations");
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/RunOnce/EndpointValidatorService.cs b/ErsatzTV/Services/RunOnce/EndpointValidatorService.cs
index 2b1b14042..d53500569 100644
--- a/ErsatzTV/Services/RunOnce/EndpointValidatorService.cs
+++ b/ErsatzTV/Services/RunOnce/EndpointValidatorService.cs
@@ -1,63 +1,56 @@
-using System;
-using System.Net;
+using System.Net;
 using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
 using ErsatzTV.Core;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Services.RunOnce
+namespace ErsatzTV.Services.RunOnce;
+
+public class EndpointValidatorService : IHostedService
 {
-    public class EndpointValidatorService : IHostedService
-    {
-        private readonly IConfiguration _configuration;
-        private readonly ILogger<EndpointValidatorService> _logger;
+    private readonly IConfiguration _configuration;
+    private readonly ILogger<EndpointValidatorService> _logger;
 
-        public EndpointValidatorService(IConfiguration configuration, ILogger<EndpointValidatorService> logger)
+    public EndpointValidatorService(IConfiguration configuration, ILogger<EndpointValidatorService> logger)
+    {
+        _configuration = configuration;
+        _logger = logger;
+    }
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        string urls = _configuration.GetValue<string>("Kestrel:Endpoints:Http:Url");
+        if (urls.Split(";").Length > 1)
         {
-            _configuration = configuration;
-            _logger = logger;
+            throw new NotSupportedException($"Multiple endpoints are not supported: {urls}");
         }
 
-        public Task StartAsync(CancellationToken cancellationToken)
+        const string PATTERN = @"http:\/\/(.*):(\d+)";
+        Match match = Regex.Match(urls, PATTERN);
+        if (match.Success)
         {
-            string urls = _configuration.GetValue<string>("Kestrel:Endpoints:Http:Url");
-            if (urls.Split(";").Length > 1)
-            {
-                throw new NotSupportedException($"Multiple endpoints are not supported: {urls}");
-            }
+            string hostname = match.Groups[1].Value;
+            Settings.ListenPort = int.Parse(match.Groups[2].Value);
 
-            const string PATTERN = @"http:\/\/(.*):(\d+)";
-            Match match = Regex.Match(urls, PATTERN);
-            if (match.Success)
+            // IP address must be 0.0.0.0 or 127.0.0.1
+            if (IPAddress.TryParse(hostname, out IPAddress address))
             {
-                string hostname = match.Groups[1].Value;
-                Settings.ListenPort = int.Parse(match.Groups[2].Value);
-
-                // IP address must be 0.0.0.0 or 127.0.0.1
-                if (IPAddress.TryParse(hostname, out IPAddress address))
+                if (!address.Equals(IPAddress.Parse("0.0.0.0")) && !IPAddress.IsLoopback(address))
                 {
-                    if (!address.Equals(IPAddress.Parse("0.0.0.0")) && !IPAddress.IsLoopback(address))
-                    {
-                        throw new NotSupportedException($"Endpoint MUST include loopback: {urls}");
-                    }
+                    throw new NotSupportedException($"Endpoint MUST include loopback: {urls}");
                 }
             }
-            else
-            {
-                throw new NotSupportedException($"Invalid endpoint format: {urls}");
-            }
-
-            _logger.LogInformation(
-                "Server will listen on port {Port} - try UI at {UI}",
-                Settings.ListenPort,
-                $"http://localhost:{Settings.ListenPort}");
-
-            return Task.CompletedTask;
+        }
+        else
+        {
+            throw new NotSupportedException($"Invalid endpoint format: {urls}");
         }
 
-        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        _logger.LogInformation(
+            "Server will listen on port {Port} - try UI at {UI}",
+            Settings.ListenPort,
+            $"http://localhost:{Settings.ListenPort}");
+
+        return Task.CompletedTask;
     }
-}
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/RunOnce/PlatformSettingsService.cs b/ErsatzTV/Services/RunOnce/PlatformSettingsService.cs
index 418a6ada1..8f47eb3c8 100644
--- a/ErsatzTV/Services/RunOnce/PlatformSettingsService.cs
+++ b/ErsatzTV/Services/RunOnce/PlatformSettingsService.cs
@@ -1,50 +1,43 @@
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Runtime;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Services.RunOnce
+namespace ErsatzTV.Services.RunOnce;
+
+public class PlatformSettingsService : IHostedService
 {
-    public class PlatformSettingsService : IHostedService
+    private readonly ILogger<PlatformSettingsService> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public PlatformSettingsService(
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<PlatformSettingsService> logger)
     {
-        private readonly ILogger<PlatformSettingsService> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
-
-        public PlatformSettingsService(
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<PlatformSettingsService> logger)
-        {
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
-        }
-
-        public async Task StartAsync(CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            await using TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
-
-            IRuntimeInfo runtimeInfo = scope.ServiceProvider.GetRequiredService<IRuntimeInfo>();
-            if (runtimeInfo != null && runtimeInfo.IsOSPlatform(OSPlatform.Linux) &&
-                System.IO.Directory.Exists("/dev/dri"))
-            {
-                ILocalFileSystem localFileSystem = scope.ServiceProvider.GetRequiredService<ILocalFileSystem>();
-                IMemoryCache memoryCache = scope.ServiceProvider.GetRequiredService<IMemoryCache>();
-
-                var devices = localFileSystem.ListFiles("/dev/dri")
-                    .Filter(s => s.StartsWith("/dev/dri/render"))
-                    .ToList();
-
-                memoryCache.Set("ffmpeg.render_devices", devices);
-            }
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
     }
-}
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        await using TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
+
+        IRuntimeInfo runtimeInfo = scope.ServiceProvider.GetRequiredService<IRuntimeInfo>();
+        if (runtimeInfo != null && runtimeInfo.IsOSPlatform(OSPlatform.Linux) &&
+            System.IO.Directory.Exists("/dev/dri"))
+        {
+            ILocalFileSystem localFileSystem = scope.ServiceProvider.GetRequiredService<ILocalFileSystem>();
+            IMemoryCache memoryCache = scope.ServiceProvider.GetRequiredService<IMemoryCache>();
+
+            var devices = localFileSystem.ListFiles("/dev/dri")
+                .Filter(s => s.StartsWith("/dev/dri/render"))
+                .ToList();
+
+            memoryCache.Set("ffmpeg.render_devices", devices);
+        }
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/RunOnce/ResourceExtractorService.cs b/ErsatzTV/Services/RunOnce/ResourceExtractorService.cs
index 78f887cec..5d132ef02 100644
--- a/ErsatzTV/Services/RunOnce/ResourceExtractorService.cs
+++ b/ErsatzTV/Services/RunOnce/ResourceExtractorService.cs
@@ -1,43 +1,38 @@
-using System.IO;
-using System.Reflection;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Reflection;
 using ErsatzTV.Core;
-using Microsoft.Extensions.Hosting;
 
-namespace ErsatzTV.Services.RunOnce
+namespace ErsatzTV.Services.RunOnce;
+
+public class ResourceExtractorService : IHostedService
 {
-    public class ResourceExtractorService : IHostedService
+    public async Task StartAsync(CancellationToken cancellationToken)
     {
-        public async Task StartAsync(CancellationToken cancellationToken)
+        if (!Directory.Exists(FileSystemLayout.ResourcesCacheFolder))
         {
-            if (!Directory.Exists(FileSystemLayout.ResourcesCacheFolder))
-            {
-                Directory.CreateDirectory(FileSystemLayout.ResourcesCacheFolder);
-            }
-
-            Assembly assembly = typeof(ResourceExtractorService).GetTypeInfo().Assembly;
-
-            await ExtractResource(assembly, "background.png", cancellationToken);
-            await ExtractResource(assembly, "song_background_1.png", cancellationToken);
-            await ExtractResource(assembly, "song_background_2.png", cancellationToken);
-            await ExtractResource(assembly, "song_background_3.png", cancellationToken);
-            await ExtractResource(assembly, "ErsatzTV.png", cancellationToken);
-            await ExtractResource(assembly, "Roboto-Regular.ttf", cancellationToken);
-            await ExtractResource(assembly, "OPTIKabel-Heavy.otf", cancellationToken);
+            Directory.CreateDirectory(FileSystemLayout.ResourcesCacheFolder);
         }
 
-        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+        Assembly assembly = typeof(ResourceExtractorService).GetTypeInfo().Assembly;
 
-        private async Task ExtractResource(Assembly assembly, string name, CancellationToken cancellationToken)
+        await ExtractResource(assembly, "background.png", cancellationToken);
+        await ExtractResource(assembly, "song_background_1.png", cancellationToken);
+        await ExtractResource(assembly, "song_background_2.png", cancellationToken);
+        await ExtractResource(assembly, "song_background_3.png", cancellationToken);
+        await ExtractResource(assembly, "ErsatzTV.png", cancellationToken);
+        await ExtractResource(assembly, "Roboto-Regular.ttf", cancellationToken);
+        await ExtractResource(assembly, "OPTIKabel-Heavy.otf", cancellationToken);
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+    private async Task ExtractResource(Assembly assembly, string name, CancellationToken cancellationToken)
+    {
+        await using Stream resource = assembly.GetManifestResourceStream($"ErsatzTV.Resources.{name}");
+        if (resource != null)
         {
-            await using Stream resource = assembly.GetManifestResourceStream($"ErsatzTV.Resources.{name}");
-            if (resource != null)
-            {
-                await using FileStream fs = File.Create(
-                    Path.Combine(FileSystemLayout.ResourcesCacheFolder, name));
-                await resource.CopyToAsync(fs, cancellationToken);
-            }
+            await using FileStream fs = File.Create(
+                Path.Combine(FileSystemLayout.ResourcesCacheFolder, name));
+            await resource.CopyToAsync(fs, cancellationToken);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/SchedulerService.cs b/ErsatzTV/Services/SchedulerService.cs
index b3326604d..345b048d8 100644
--- a/ErsatzTV/Services/SchedulerService.cs
+++ b/ErsatzTV/Services/SchedulerService.cs
@@ -1,205 +1,196 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Application;
-using ErsatzTV.Application.Maintenance.Commands;
-using ErsatzTV.Application.MediaCollections.Commands;
-using ErsatzTV.Application.MediaSources.Commands;
-using ErsatzTV.Application.Playouts.Commands;
-using ErsatzTV.Application.Plex.Commands;
-using ErsatzTV.Application.Search.Commands;
+using ErsatzTV.Application.Maintenance;
+using ErsatzTV.Application.MediaCollections;
+using ErsatzTV.Application.MediaSources;
+using ErsatzTV.Application.Playouts;
+using ErsatzTV.Application.Plex;
+using ErsatzTV.Application.Search;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
-namespace ErsatzTV.Services
+namespace ErsatzTV.Services;
+
+public class SchedulerService : BackgroundService
 {
-    public class SchedulerService : BackgroundService
-    {
-        private readonly IEntityLocker _entityLocker;
-        private readonly ILogger<SchedulerService> _logger;
-        private readonly ChannelWriter<IPlexBackgroundServiceRequest> _plexWorkerChannel;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
-        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+    private readonly IEntityLocker _entityLocker;
+    private readonly ILogger<SchedulerService> _logger;
+    private readonly ChannelWriter<IPlexBackgroundServiceRequest> _plexWorkerChannel;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+    private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
 
-        public SchedulerService(
-            IServiceScopeFactory serviceScopeFactory,
-            ChannelWriter<IBackgroundServiceRequest> workerChannel,
-            ChannelWriter<IPlexBackgroundServiceRequest> plexWorkerChannel,
-            IEntityLocker entityLocker,
-            ILogger<SchedulerService> logger)
+    public SchedulerService(
+        IServiceScopeFactory serviceScopeFactory,
+        ChannelWriter<IBackgroundServiceRequest> workerChannel,
+        ChannelWriter<IPlexBackgroundServiceRequest> plexWorkerChannel,
+        IEntityLocker entityLocker,
+        ILogger<SchedulerService> logger)
+    {
+        _serviceScopeFactory = serviceScopeFactory;
+        _workerChannel = workerChannel;
+        _plexWorkerChannel = plexWorkerChannel;
+        _entityLocker = entityLocker;
+        _logger = logger;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    {
+        DateTime firstRun = DateTime.Now;
+            
+        // run once immediately at startup
+        if (!cancellationToken.IsCancellationRequested)
         {
-            _serviceScopeFactory = serviceScopeFactory;
-            _workerChannel = workerChannel;
-            _plexWorkerChannel = plexWorkerChannel;
-            _entityLocker = entityLocker;
-            _logger = logger;
+            await DoWork(cancellationToken);
         }
 
-        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+        while (!cancellationToken.IsCancellationRequested)
         {
-            DateTime firstRun = DateTime.Now;
-            
-            // run once immediately at startup
+            int currentMinutes = DateTime.Now.TimeOfDay.Minutes;
+            int toWait = currentMinutes < 30 ? 30 - currentMinutes : 60 - currentMinutes;
+            _logger.LogDebug("Scheduler sleeping for {Minutes} minutes", toWait);
+            await Task.Delay(TimeSpan.FromMinutes(toWait), cancellationToken);
+                
             if (!cancellationToken.IsCancellationRequested)
             {
-                await DoWork(cancellationToken);
-            }
-
-            while (!cancellationToken.IsCancellationRequested)
-            {
-                int currentMinutes = DateTime.Now.TimeOfDay.Minutes;
-                int toWait = currentMinutes < 30 ? 30 - currentMinutes : 60 - currentMinutes;
-                _logger.LogDebug("Scheduler sleeping for {Minutes} minutes", toWait);
-                await Task.Delay(TimeSpan.FromMinutes(toWait), cancellationToken);
-                
-                if (!cancellationToken.IsCancellationRequested)
+                var roundedMinute = (int)(Math.Round(DateTime.Now.Minute / 5.0) * 5);
+                if (roundedMinute % 30 == 0)
                 {
-                    var roundedMinute = (int)(Math.Round(DateTime.Now.Minute / 5.0) * 5);
-                    if (roundedMinute % 30 == 0)
-                    {
-                        // check for playouts to rebuild every 30 minutes
-                        await RebuildPlayouts(cancellationToken);
-                    }
-                    if (roundedMinute % 60 == 0 && DateTime.Now.Subtract(firstRun) > TimeSpan.FromHours(1))
-                    {
-                        // do other work every hour (on the hour)
-                        await DoWork(cancellationToken);
-                    }
+                    // check for playouts to rebuild every 30 minutes
+                    await RebuildPlayouts(cancellationToken);
+                }
+                if (roundedMinute % 60 == 0 && DateTime.Now.Subtract(firstRun) > TimeSpan.FromHours(1))
+                {
+                    // do other work every hour (on the hour)
+                    await DoWork(cancellationToken);
                 }
             }
         }
+    }
 
-        private async Task DoWork(CancellationToken cancellationToken)
+    private async Task DoWork(CancellationToken cancellationToken)
+    {
+        try
         {
-            try
-            {
-                await DeleteOrphanedArtwork(cancellationToken);
-                await RebuildSearchIndex(cancellationToken);
-                await BuildPlayouts(cancellationToken);
-                await ScanLocalMediaSources(cancellationToken);
-                await ScanPlexMediaSources(cancellationToken);
-                await MatchTraktLists(cancellationToken);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error during scheduler run");
-            }
+            await DeleteOrphanedArtwork(cancellationToken);
+            await RebuildSearchIndex(cancellationToken);
+            await BuildPlayouts(cancellationToken);
+            await ScanLocalMediaSources(cancellationToken);
+            await ScanPlexMediaSources(cancellationToken);
+            await MatchTraktLists(cancellationToken);
         }
-
-        private async Task RebuildPlayouts(CancellationToken cancellationToken)
+        catch (Exception ex)
         {
-            try
-            {
-                using IServiceScope scope = _serviceScopeFactory.CreateScope();
-                TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
-
-                List<Playout> playouts = await dbContext.Playouts
-                    .Filter(p => p.DailyRebuildTime != null)
-                    .Include(p => p.Channel)
-                    .ToListAsync(cancellationToken);
-
-                foreach (Playout playout in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)))
-                {
-                    if (DateTime.Now.Subtract(DateTime.Today.Add(playout.DailyRebuildTime ?? TimeSpan.FromDays(7))) <
-                        TimeSpan.FromMinutes(5))
-                    {
-                        await _workerChannel.WriteAsync(new BuildPlayout(playout.Id, true), cancellationToken);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogWarning(ex, "Error during scheduler run");
-            }
+            _logger.LogWarning(ex, "Error during scheduler run");
         }
+    }
 
-        private async Task BuildPlayouts(CancellationToken cancellationToken)
+    private async Task RebuildPlayouts(CancellationToken cancellationToken)
+    {
+        try
         {
             using IServiceScope scope = _serviceScopeFactory.CreateScope();
             TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
 
             List<Playout> playouts = await dbContext.Playouts
+                .Filter(p => p.DailyRebuildTime != null)
                 .Include(p => p.Channel)
                 .ToListAsync(cancellationToken);
-            foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)).Map(p => p.Id))
+
+            foreach (Playout playout in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)))
             {
-                await _workerChannel.WriteAsync(new BuildPlayout(playoutId), cancellationToken);
-            }
-        }
-
-        private async Task ScanLocalMediaSources(CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
-
-            List<int> localLibraryIds = await dbContext.LocalMediaSources
-                .SelectMany(ms => ms.Libraries)
-                .Map(l => l.Id)
-                .ToListAsync(cancellationToken);
-
-            foreach (int libraryId in localLibraryIds)
-            {
-                if (_entityLocker.LockLibrary(libraryId))
+                if (DateTime.Now.Subtract(DateTime.Today.Add(playout.DailyRebuildTime ?? TimeSpan.FromDays(7))) <
+                    TimeSpan.FromMinutes(5))
                 {
-                    await _workerChannel.WriteAsync(
-                        new ScanLocalLibraryIfNeeded(libraryId),
-                        cancellationToken);
+                    await _workerChannel.WriteAsync(new BuildPlayout(playout.Id, true), cancellationToken);
                 }
             }
         }
-
-        private async Task ScanPlexMediaSources(CancellationToken cancellationToken)
+        catch (Exception ex)
         {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
-
-            List<PlexLibrary> plexLibraries = await dbContext.PlexLibraries
-                .Filter(l => l.ShouldSyncItems)
-                .ToListAsync(cancellationToken);
-
-            foreach (PlexLibrary library in plexLibraries)
-            {
-                if (_entityLocker.LockLibrary(library.Id))
-                {
-                    await _plexWorkerChannel.WriteAsync(
-                        new SynchronizePlexLibraryByIdIfNeeded(library.Id),
-                        cancellationToken);
-                }
-            }
+            _logger.LogWarning(ex, "Error during scheduler run");
         }
-
-        private async Task MatchTraktLists(CancellationToken cancellationToken)
-        {
-            using IServiceScope scope = _serviceScopeFactory.CreateScope();
-            TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
-
-            List<TraktList> traktLists = await dbContext.TraktLists
-                .ToListAsync(cancellationToken);
-
-            if (traktLists.Any() && _entityLocker.LockTrakt())
-            {
-                TraktList last = traktLists.Last();
-                foreach (TraktList list in traktLists)
-                {
-                    await _workerChannel.WriteAsync(
-                        new MatchTraktListItems(list.Id, list == last),
-                        cancellationToken);
-                }
-            }
-        }
-
-        private ValueTask RebuildSearchIndex(CancellationToken cancellationToken) =>
-            _workerChannel.WriteAsync(new RebuildSearchIndex(), cancellationToken);
-
-        private ValueTask DeleteOrphanedArtwork(CancellationToken cancellationToken) =>
-            _workerChannel.WriteAsync(new DeleteOrphanedArtwork(), cancellationToken);
     }
-}
+
+    private async Task BuildPlayouts(CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
+
+        List<Playout> playouts = await dbContext.Playouts
+            .Include(p => p.Channel)
+            .ToListAsync(cancellationToken);
+        foreach (int playoutId in playouts.OrderBy(p => decimal.Parse(p.Channel.Number)).Map(p => p.Id))
+        {
+            await _workerChannel.WriteAsync(new BuildPlayout(playoutId), cancellationToken);
+        }
+    }
+
+    private async Task ScanLocalMediaSources(CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
+
+        List<int> localLibraryIds = await dbContext.LocalMediaSources
+            .SelectMany(ms => ms.Libraries)
+            .Map(l => l.Id)
+            .ToListAsync(cancellationToken);
+
+        foreach (int libraryId in localLibraryIds)
+        {
+            if (_entityLocker.LockLibrary(libraryId))
+            {
+                await _workerChannel.WriteAsync(
+                    new ScanLocalLibraryIfNeeded(libraryId),
+                    cancellationToken);
+            }
+        }
+    }
+
+    private async Task ScanPlexMediaSources(CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
+
+        List<PlexLibrary> plexLibraries = await dbContext.PlexLibraries
+            .Filter(l => l.ShouldSyncItems)
+            .ToListAsync(cancellationToken);
+
+        foreach (PlexLibrary library in plexLibraries)
+        {
+            if (_entityLocker.LockLibrary(library.Id))
+            {
+                await _plexWorkerChannel.WriteAsync(
+                    new SynchronizePlexLibraryByIdIfNeeded(library.Id),
+                    cancellationToken);
+            }
+        }
+    }
+
+    private async Task MatchTraktLists(CancellationToken cancellationToken)
+    {
+        using IServiceScope scope = _serviceScopeFactory.CreateScope();
+        TvContext dbContext = scope.ServiceProvider.GetRequiredService<TvContext>();
+
+        List<TraktList> traktLists = await dbContext.TraktLists
+            .ToListAsync(cancellationToken);
+
+        if (traktLists.Any() && _entityLocker.LockTrakt())
+        {
+            TraktList last = traktLists.Last();
+            foreach (TraktList list in traktLists)
+            {
+                await _workerChannel.WriteAsync(
+                    new MatchTraktListItems(list.Id, list == last),
+                    cancellationToken);
+            }
+        }
+    }
+
+    private ValueTask RebuildSearchIndex(CancellationToken cancellationToken) =>
+        _workerChannel.WriteAsync(new RebuildSearchIndex(), cancellationToken);
+
+    private ValueTask DeleteOrphanedArtwork(CancellationToken cancellationToken) =>
+        _workerChannel.WriteAsync(new DeleteOrphanedArtwork(), cancellationToken);
+}
\ No newline at end of file
diff --git a/ErsatzTV/Services/WorkerService.cs b/ErsatzTV/Services/WorkerService.cs
index 90de7a894..11392c849 100644
--- a/ErsatzTV/Services/WorkerService.cs
+++ b/ErsatzTV/Services/WorkerService.cs
@@ -1,99 +1,90 @@
-using System;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
+using System.Threading.Channels;
 using ErsatzTV.Application;
-using ErsatzTV.Application.Maintenance.Commands;
-using ErsatzTV.Application.MediaCollections.Commands;
-using ErsatzTV.Application.MediaSources.Commands;
-using ErsatzTV.Application.Playouts.Commands;
-using ErsatzTV.Application.Search.Commands;
+using ErsatzTV.Application.Maintenance;
+using ErsatzTV.Application.MediaCollections;
+using ErsatzTV.Application.MediaSources;
+using ErsatzTV.Application.Playouts;
+using ErsatzTV.Application.Search;
 using ErsatzTV.Core;
-using LanguageExt;
 using MediatR;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.Services
+namespace ErsatzTV.Services;
+
+public class WorkerService : BackgroundService
 {
-    public class WorkerService : BackgroundService
+    private readonly ChannelReader<IBackgroundServiceRequest> _channel;
+    private readonly ILogger<WorkerService> _logger;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+
+    public WorkerService(
+        ChannelReader<IBackgroundServiceRequest> channel,
+        IServiceScopeFactory serviceScopeFactory,
+        ILogger<WorkerService> logger)
     {
-        private readonly ChannelReader<IBackgroundServiceRequest> _channel;
-        private readonly ILogger<WorkerService> _logger;
-        private readonly IServiceScopeFactory _serviceScopeFactory;
+        _channel = channel;
+        _serviceScopeFactory = serviceScopeFactory;
+        _logger = logger;
+    }
 
-        public WorkerService(
-            ChannelReader<IBackgroundServiceRequest> channel,
-            IServiceScopeFactory serviceScopeFactory,
-            ILogger<WorkerService> logger)
+    protected override async Task ExecuteAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Worker service started");
+
+        await foreach (IBackgroundServiceRequest request in _channel.ReadAllAsync(cancellationToken))
         {
-            _channel = channel;
-            _serviceScopeFactory = serviceScopeFactory;
-            _logger = logger;
-        }
-
-        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
-        {
-            _logger.LogInformation("Worker service started");
-
-            await foreach (IBackgroundServiceRequest request in _channel.ReadAllAsync(cancellationToken))
+            try
             {
-                try
-                {
-                    using IServiceScope scope = _serviceScopeFactory.CreateScope();
-                    IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+                using IServiceScope scope = _serviceScopeFactory.CreateScope();
+                IMediator mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
 
-                    switch (request)
-                    {
-                        case BuildPlayout buildPlayout:
-                            Either<BaseError, Unit> buildPlayoutResult = await mediator.Send(
-                                buildPlayout,
-                                cancellationToken);
-                            buildPlayoutResult.BiIter(
-                                _ => _logger.LogDebug("Built playout {PlayoutId}", buildPlayout.PlayoutId),
-                                error => _logger.LogWarning(
-                                    "Unable to build playout {PlayoutId}: {Error}",
-                                    buildPlayout.PlayoutId,
-                                    error.Value));
-                            break;
-                        case IScanLocalLibrary scanLocalLibrary:
-                            Either<BaseError, string> scanResult = await mediator.Send(
-                                scanLocalLibrary,
-                                cancellationToken);
-                            scanResult.BiIter(
-                                name => _logger.LogDebug(
-                                    "Done scanning local library {Library}",
-                                    name),
-                                error => _logger.LogWarning(
-                                    "Unable to scan local library {LibraryId}: {Error}",
-                                    scanLocalLibrary.LibraryId,
-                                    error.Value));
-                            break;
-                        case RebuildSearchIndex rebuildSearchIndex:
-                            await mediator.Send(rebuildSearchIndex, cancellationToken);
-                            break;
-                        case DeleteOrphanedArtwork deleteOrphanedArtwork:
-                            _logger.LogInformation("Deleting orphaned artwork from the database");
-                            await mediator.Send(deleteOrphanedArtwork, cancellationToken);
-                            break;
-                        case AddTraktList addTraktList:
-                            await mediator.Send(addTraktList, cancellationToken);
-                            break;
-                        case DeleteTraktList deleteTraktList:
-                            await mediator.Send(deleteTraktList, cancellationToken);
-                            break;
-                        case MatchTraktListItems matchTraktListItems:
-                            await mediator.Send(matchTraktListItems, cancellationToken);
-                            break;
-                    }
-                }
-                catch (Exception ex)
+                switch (request)
                 {
-                    _logger.LogWarning(ex, "Failed to process background service request");
+                    case BuildPlayout buildPlayout:
+                        Either<BaseError, Unit> buildPlayoutResult = await mediator.Send(
+                            buildPlayout,
+                            cancellationToken);
+                        buildPlayoutResult.BiIter(
+                            _ => _logger.LogDebug("Built playout {PlayoutId}", buildPlayout.PlayoutId),
+                            error => _logger.LogWarning(
+                                "Unable to build playout {PlayoutId}: {Error}",
+                                buildPlayout.PlayoutId,
+                                error.Value));
+                        break;
+                    case IScanLocalLibrary scanLocalLibrary:
+                        Either<BaseError, string> scanResult = await mediator.Send(
+                            scanLocalLibrary,
+                            cancellationToken);
+                        scanResult.BiIter(
+                            name => _logger.LogDebug(
+                                "Done scanning local library {Library}",
+                                name),
+                            error => _logger.LogWarning(
+                                "Unable to scan local library {LibraryId}: {Error}",
+                                scanLocalLibrary.LibraryId,
+                                error.Value));
+                        break;
+                    case RebuildSearchIndex rebuildSearchIndex:
+                        await mediator.Send(rebuildSearchIndex, cancellationToken);
+                        break;
+                    case DeleteOrphanedArtwork deleteOrphanedArtwork:
+                        _logger.LogInformation("Deleting orphaned artwork from the database");
+                        await mediator.Send(deleteOrphanedArtwork, cancellationToken);
+                        break;
+                    case AddTraktList addTraktList:
+                        await mediator.Send(addTraktList, cancellationToken);
+                        break;
+                    case DeleteTraktList deleteTraktList:
+                        await mediator.Send(deleteTraktList, cancellationToken);
+                        break;
+                    case MatchTraktListItems matchTraktListItems:
+                        await mediator.Send(matchTraktListItems, cancellationToken);
+                        break;
                 }
             }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to process background service request");
+            }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Shared/AddToCollectionDialog.razor b/ErsatzTV/Shared/AddToCollectionDialog.razor
index adfa0bec2..d936acee0 100644
--- a/ErsatzTV/Shared/AddToCollectionDialog.razor
+++ b/ErsatzTV/Shared/AddToCollectionDialog.razor
@@ -1,8 +1,5 @@
 @using Microsoft.Extensions.Caching.Memory
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.MediaCollections.Queries
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject IMemoryCache _memoryCache
diff --git a/ErsatzTV/Shared/AddToScheduleDialog.razor b/ErsatzTV/Shared/AddToScheduleDialog.razor
index f18947b51..245490376 100644
--- a/ErsatzTV/Shared/AddToScheduleDialog.razor
+++ b/ErsatzTV/Shared/AddToScheduleDialog.razor
@@ -1,7 +1,5 @@
 @using ErsatzTV.Application.ProgramSchedules
-@using ErsatzTV.Application.ProgramSchedules.Queries
 @using NaturalSort.Extension
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 
diff --git a/ErsatzTV/Shared/CopyFFmpegProfileDialog.razor b/ErsatzTV/Shared/CopyFFmpegProfileDialog.razor
index 221de01d9..601425be8 100644
--- a/ErsatzTV/Shared/CopyFFmpegProfileDialog.razor
+++ b/ErsatzTV/Shared/CopyFFmpegProfileDialog.razor
@@ -1,6 +1,4 @@
 @using ErsatzTV.Application.FFmpegProfiles
-@using ErsatzTV.Application.FFmpegProfiles.Commands
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject ISnackbar _snackbar
diff --git a/ErsatzTV/Shared/CopyWatermarkDialog.razor b/ErsatzTV/Shared/CopyWatermarkDialog.razor
index c94d54b6c..2a042053e 100644
--- a/ErsatzTV/Shared/CopyWatermarkDialog.razor
+++ b/ErsatzTV/Shared/CopyWatermarkDialog.razor
@@ -1,6 +1,4 @@
 @using ErsatzTV.Application.Watermarks
-@using ErsatzTV.Application.Watermarks.Commands
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject ISnackbar _snackbar
diff --git a/ErsatzTV/Shared/FragmentLetterAnchor.razor.cs b/ErsatzTV/Shared/FragmentLetterAnchor.razor.cs
index 9698193ac..b2f0f7508 100644
--- a/ErsatzTV/Shared/FragmentLetterAnchor.razor.cs
+++ b/ErsatzTV/Shared/FragmentLetterAnchor.razor.cs
@@ -1,15 +1,13 @@
-using System.Collections.Generic;
-using ErsatzTV.Application.MediaCards;
+using ErsatzTV.Application.MediaCards;
 using Microsoft.AspNetCore.Components;
 
-namespace ErsatzTV.Shared
-{
-    public partial class FragmentLetterAnchor<TCard> where TCard : MediaCardViewModel
-    {
-        [Parameter]
-        public RenderFragment<TCard> ChildContent { get; set; }
+namespace ErsatzTV.Shared;
 
-        [Parameter]
-        public List<TCard> Cards { get; set; }
-    }
-}
+public partial class FragmentLetterAnchor<TCard> where TCard : MediaCardViewModel
+{
+    [Parameter]
+    public RenderFragment<TCard> ChildContent { get; set; }
+
+    [Parameter]
+    public List<TCard> Cards { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Shared/LetterBar.razor b/ErsatzTV/Shared/LetterBar.razor
index 235374804..e0460bb2a 100644
--- a/ErsatzTV/Shared/LetterBar.razor
+++ b/ErsatzTV/Shared/LetterBar.razor
@@ -1,6 +1,5 @@
-@using ErsatzTV.Core.Search
-@using ErsatzTV.Extensions
-@using Microsoft.AspNetCore.WebUtilities
+@using ErsatzTV.Extensions
+@using ErsatzTV.Core.Search
 <div class="letter-bar-container">
     <div class="letter-bar">
         <MudLink Href="@GetLinkForLetter('#')">#</MudLink>
diff --git a/ErsatzTV/Shared/MarkdownView.razor.cs b/ErsatzTV/Shared/MarkdownView.razor.cs
index 2825ee7b5..c5dbfca64 100644
--- a/ErsatzTV/Shared/MarkdownView.razor.cs
+++ b/ErsatzTV/Shared/MarkdownView.razor.cs
@@ -1,64 +1,61 @@
-using System;
-using System.Threading.Tasks;
-using Ganss.XSS;
+using Ganss.XSS;
 using Markdig;
 using Microsoft.AspNetCore.Components;
 using Microsoft.JSInterop;
 
-namespace ErsatzTV.Shared
+namespace ErsatzTV.Shared;
+
+public partial class MarkdownView
 {
-    public partial class MarkdownView
+    private string _content;
+
+    [Inject]
+    public IHtmlSanitizer HtmlSanitizer { get; set; }
+
+    [Inject]
+    public IJSRuntime JsRuntime { get; set; }
+
+    [Parameter]
+    public string Content
     {
-        private string _content;
-
-        [Inject]
-        public IHtmlSanitizer HtmlSanitizer { get; set; }
-
-        [Inject]
-        public IJSRuntime JsRuntime { get; set; }
-
-        [Parameter]
-        public string Content
+        get => _content;
+        set
         {
-            get => _content;
-            set
-            {
-                _content = value;
-                HtmlContent = ConvertStringToMarkupString(_content);
-            }
-        }
-
-        public MarkupString HtmlContent { get; private set; }
-
-        private MarkupString ConvertStringToMarkupString(string value)
-        {
-            if (!string.IsNullOrWhiteSpace(_content))
-            {
-                // Convert markdown string to HTML
-                string html = Markdown.ToHtml(value, new MarkdownPipelineBuilder().UseAdvancedExtensions().Build());
-
-                // Sanitize HTML before rendering
-                string sanitizedHtml = HtmlSanitizer.Sanitize(html);
-
-                // Return sanitized HTML as a MarkupString that Blazor can render
-                return new MarkupString(sanitizedHtml);
-            }
-
-            return new MarkupString();
-        }
-
-        protected override async Task OnAfterRenderAsync(bool firstRender)
-        {
-            try
-            {
-                await JsRuntime.InvokeVoidAsync("styleMarkdown");
-            }
-            catch (Exception)
-            {
-                // ignored
-            }
-
-            await base.OnAfterRenderAsync(true);
+            _content = value;
+            HtmlContent = ConvertStringToMarkupString(_content);
         }
     }
-}
+
+    public MarkupString HtmlContent { get; private set; }
+
+    private MarkupString ConvertStringToMarkupString(string value)
+    {
+        if (!string.IsNullOrWhiteSpace(_content))
+        {
+            // Convert markdown string to HTML
+            string html = Markdown.ToHtml(value, new MarkdownPipelineBuilder().UseAdvancedExtensions().Build());
+
+            // Sanitize HTML before rendering
+            string sanitizedHtml = HtmlSanitizer.Sanitize(html);
+
+            // Return sanitized HTML as a MarkupString that Blazor can render
+            return new MarkupString(sanitizedHtml);
+        }
+
+        return new MarkupString();
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        try
+        {
+            await JsRuntime.InvokeVoidAsync("styleMarkdown");
+        }
+        catch (Exception)
+        {
+            // ignored
+        }
+
+        await base.OnAfterRenderAsync(true);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Shared/MediaCard.razor b/ErsatzTV/Shared/MediaCard.razor
index 02a61493f..05d87d0fb 100644
--- a/ErsatzTV/Shared/MediaCard.razor
+++ b/ErsatzTV/Shared/MediaCard.razor
@@ -1,6 +1,5 @@
 @using static LanguageExt.Prelude
 @using ErsatzTV.Application.MediaCards
-@using Unit = LanguageExt.Unit
 @inject IMediator _mediator
 
 <div class="@((ContainerClass ?? "media-card-container mr-6") + " pb-3")" id="@($"item_{Data.MediaItemId}")">
diff --git a/ErsatzTV/Shared/MoveLocalLibraryPathDialog.razor b/ErsatzTV/Shared/MoveLocalLibraryPathDialog.razor
index d36eabe9b..0272cefeb 100644
--- a/ErsatzTV/Shared/MoveLocalLibraryPathDialog.razor
+++ b/ErsatzTV/Shared/MoveLocalLibraryPathDialog.razor
@@ -1,8 +1,5 @@
 @using Microsoft.Extensions.Caching.Memory
 @using ErsatzTV.Application.Libraries
-@using ErsatzTV.Application.Libraries.Commands
-@using ErsatzTV.Application.Libraries.Queries
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject IMemoryCache _memoryCache
diff --git a/ErsatzTV/Shared/RemoteMediaSourceEditor.razor b/ErsatzTV/Shared/RemoteMediaSourceEditor.razor
index 5f042fd87..689dda27b 100644
--- a/ErsatzTV/Shared/RemoteMediaSourceEditor.razor
+++ b/ErsatzTV/Shared/RemoteMediaSourceEditor.razor
@@ -1,5 +1,4 @@
-@using Unit = LanguageExt.Unit
-@inject IMediator _mediator
+@inject IMediator _mediator
 @inject NavigationManager _navigationManager
 @inject ISnackbar _snackbar
 @inject ILogger<RemoteMediaSourceEditor> _logger
diff --git a/ErsatzTV/Shared/RemoteMediaSourceLibrariesEditor.razor b/ErsatzTV/Shared/RemoteMediaSourceLibrariesEditor.razor
index eab6c3f97..23fd3db15 100644
--- a/ErsatzTV/Shared/RemoteMediaSourceLibrariesEditor.razor
+++ b/ErsatzTV/Shared/RemoteMediaSourceLibrariesEditor.razor
@@ -1,6 +1,4 @@
 @using ErsatzTV.Application.MediaSources
-@using Unit = LanguageExt.Unit
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject NavigationManager _navigationManager
diff --git a/ErsatzTV/Shared/RemoteMediaSourcePathReplacementsEditor.razor b/ErsatzTV/Shared/RemoteMediaSourcePathReplacementsEditor.razor
index bd33adbfd..a30658ac2 100644
--- a/ErsatzTV/Shared/RemoteMediaSourcePathReplacementsEditor.razor
+++ b/ErsatzTV/Shared/RemoteMediaSourcePathReplacementsEditor.razor
@@ -1,6 +1,4 @@
 @using ErsatzTV.Application.MediaSources
-@using Unit = LanguageExt.Unit
-@using System.Threading
 @implements IDisposable
 @inject NavigationManager _navigationManager
 @inject ILogger<RemoteMediaSourcePathReplacementsEditor> _logger
diff --git a/ErsatzTV/Shared/RemoteMediaSources.razor b/ErsatzTV/Shared/RemoteMediaSources.razor
index 1957479c3..27b537795 100644
--- a/ErsatzTV/Shared/RemoteMediaSources.razor
+++ b/ErsatzTV/Shared/RemoteMediaSources.razor
@@ -1,9 +1,7 @@
 @typeparam TViewModel
 @typeparam TSecrets
-@using Unit = LanguageExt.Unit
-@using ErsatzTV.Core.Interfaces.MediaSources
-@using System.Threading
 @implements IDisposable
+@using ErsatzTV.Core.Interfaces.MediaSources
 @typeparam TMediaSource
 @inject IMediator _mediator
 @inject IDialogService _dialog
diff --git a/ErsatzTV/Shared/RemoteMediaSources.razor.cs b/ErsatzTV/Shared/RemoteMediaSources.razor.cs
index 233165179..7ca09d127 100644
--- a/ErsatzTV/Shared/RemoteMediaSources.razor.cs
+++ b/ErsatzTV/Shared/RemoteMediaSources.razor.cs
@@ -1,11 +1,10 @@
 using ErsatzTV.Application.MediaSources;
 using ErsatzTV.Core.MediaSources;
 
-namespace ErsatzTV.Shared
+namespace ErsatzTV.Shared;
+
+public partial class RemoteMediaSources<TViewModel, TSecrets, TMediaSource>
+    where TViewModel : RemoteMediaSourceViewModel
+    where TSecrets : RemoteMediaSourceSecrets
 {
-    public partial class RemoteMediaSources<TViewModel, TSecrets, TMediaSource>
-        where TViewModel : RemoteMediaSourceViewModel
-        where TSecrets : RemoteMediaSourceSecrets
-    {
-    }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Shared/SaveAsSmartCollectionDialog.razor b/ErsatzTV/Shared/SaveAsSmartCollectionDialog.razor
index d1128c04a..0edcce624 100644
--- a/ErsatzTV/Shared/SaveAsSmartCollectionDialog.razor
+++ b/ErsatzTV/Shared/SaveAsSmartCollectionDialog.razor
@@ -1,8 +1,5 @@
 @using Microsoft.Extensions.Caching.Memory
 @using ErsatzTV.Application.MediaCollections
-@using ErsatzTV.Application.MediaCollections.Commands
-@using ErsatzTV.Application.MediaCollections.Queries
-@using System.Threading
 @implements IDisposable
 @inject IMediator _mediator
 @inject IMemoryCache _memoryCache
diff --git a/ErsatzTV/Shared/SchedulePlayoutRebuild.razor b/ErsatzTV/Shared/SchedulePlayoutRebuild.razor
index ef92df0b7..a7b685bbe 100644
--- a/ErsatzTV/Shared/SchedulePlayoutRebuild.razor
+++ b/ErsatzTV/Shared/SchedulePlayoutRebuild.razor
@@ -1,7 +1,4 @@
-@using System.Globalization
-@using ErsatzTV.Application.Playouts
-@using ErsatzTV.Application.Playouts.Commands
-@using System.Threading
+@using ErsatzTV.Application.Playouts
 @implements IDisposable
 @inject IMediator _mediator
 @inject ISnackbar _snackbar
diff --git a/ErsatzTV/Startup.cs b/ErsatzTV/Startup.cs
index 8aed3de3c..20f847c48 100644
--- a/ErsatzTV/Startup.cs
+++ b/ErsatzTV/Startup.cs
@@ -1,15 +1,12 @@
-using System;
 using System.Data;
-using System.IO;
 using System.Reflection;
 using System.Text;
 using System.Threading.Channels;
 using Bugsnag.AspNet.Core;
 using Dapper;
 using ErsatzTV.Application;
-using ErsatzTV.Application.Channels.Queries;
+using ErsatzTV.Application.Channels;
 using ErsatzTV.Application.Streaming;
-using ErsatzTV.Application.Streaming.Commands;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Errors;
@@ -57,13 +54,9 @@ using FluentValidation.AspNetCore;
 using Ganss.XSS;
 using MediatR;
 using MediatR.Courier.DependencyInjection;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.StaticFiles;
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.FileProviders;
 using MudBlazor.Services;
 using Newtonsoft.Json;
@@ -71,317 +64,321 @@ using Newtonsoft.Json.Converters;
 using Refit;
 using Serilog;
 
-namespace ErsatzTV
+namespace ErsatzTV;
+
+public class Startup
 {
-    public class Startup
+    public Startup(IConfiguration configuration) => Configuration = configuration;
+
+    public IConfiguration Configuration { get; }
+
+    public void ConfigureServices(IServiceCollection services)
     {
-        public Startup(IConfiguration configuration) => Configuration = configuration;
+        BugsnagConfiguration bugsnagConfig = Configuration.GetSection("Bugsnag").Get<BugsnagConfiguration>();
+        services.Configure<BugsnagConfiguration>(Configuration.GetSection("Bugsnag"));
 
-        public IConfiguration Configuration { get; }
-
-        public void ConfigureServices(IServiceCollection services)
-        {
-            BugsnagConfiguration bugsnagConfig = Configuration.GetSection("Bugsnag").Get<BugsnagConfiguration>();
-            services.Configure<BugsnagConfiguration>(Configuration.GetSection("Bugsnag"));
-
-            services.AddBugsnag(
-                configuration =>
-                {
-                    configuration.ApiKey = bugsnagConfig.ApiKey;
-                    configuration.ProjectNamespaces = new[] { "ErsatzTV" };
-                    configuration.AppVersion = Assembly.GetEntryAssembly()
-                        ?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
-                        ?.InformationalVersion ?? "unknown";
+        services.AddBugsnag(
+            configuration =>
+            {
+                configuration.ApiKey = bugsnagConfig.ApiKey;
+                configuration.ProjectNamespaces = new[] { "ErsatzTV" };
+                configuration.AppVersion = Assembly.GetEntryAssembly()
+                    ?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
+                    ?.InformationalVersion ?? "unknown";
                     
-                    configuration.NotifyReleaseStages = new[] { "public", "develop" };
+                configuration.NotifyReleaseStages = new[] { "public", "develop" };
                     
 #if DEBUG
-                    configuration.ReleaseStage = "develop";
+                configuration.ReleaseStage = "develop";
 #else
                     // effectively "disable" by tweaking app config
                     configuration.ReleaseStage = bugsnagConfig.Enable ? "public" : "private";
 #endif
-                });
+            });
             
-            services.AddCors(
-                o => o.AddPolicy(
-                    "AllowAll",
-                    builder =>
-                    {
-                        builder.AllowAnyOrigin()
-                            .AllowAnyMethod()
-                            .AllowAnyHeader();
-                    }));
-
-            services.AddControllers(
-                    options =>
-                    {
-                        options.OutputFormatters.Insert(0, new ConcatPlaylistOutputFormatter());
-                        options.OutputFormatters.Insert(0, new ChannelPlaylistOutputFormatter());
-                        options.OutputFormatters.Insert(0, new ChannelGuideOutputFormatter());
-                        options.OutputFormatters.Insert(0, new DeviceXmlOutputFormatter());
-                        options.OutputFormatters.Insert(0, new HdhrJsonOutputFormatter());
-                    })
-                .AddNewtonsoftJson(
-                    opt =>
-                    {
-                        opt.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
-                        opt.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
-                        opt.SerializerSettings.ContractResolver = new CustomContractResolver();
-                        opt.SerializerSettings.Converters.Add(new StringEnumConverter());
-                    })
-                .AddFluentValidation(
-                    options =>
-                    {
-                        options.RegisterValidatorsFromAssemblyContaining<Startup>();
-                        options.ImplicitlyValidateChildProperties = true;
-                    });
-
-            services.AddRazorPages();
-            services.AddServerSideBlazor();
-
-            services.AddMudServices();
-            services.AddCourier(Assembly.GetAssembly(typeof(LibraryScanProgress)));
-
-            Console.OutputEncoding = Encoding.UTF8;
-
-            Log.Logger.Information(
-                "ErsatzTV version {Version}",
-                Assembly.GetEntryAssembly()?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
-                    ?.InformationalVersion ?? "unknown");
-
-            Log.Logger.Warning("This is alpha software and is likely to be unstable");
-            Log.Logger.Warning(
-                "Give feedback at {GitHub} or {Discord}",
-                "https://github.com/jasongdove/ErsatzTV",
-                "https://discord.gg/hHaJm3yGy6");
-
-            if (!Directory.Exists(FileSystemLayout.AppDataFolder))
-            {
-                Directory.CreateDirectory(FileSystemLayout.AppDataFolder);
-            }
-
-            if (!Directory.Exists(FileSystemLayout.TranscodeFolder))
-            {
-                Directory.CreateDirectory(FileSystemLayout.TranscodeFolder);
-            }
-
-            if (!Directory.Exists(FileSystemLayout.TempFilePoolFolder))
-            {
-                Directory.CreateDirectory(FileSystemLayout.TempFilePoolFolder);
-            }
-
-            Log.Logger.Information("Database is at {DatabasePath}", FileSystemLayout.DatabasePath);
-
-            // until we add a setting for a file-specific scheme://host:port to access
-            // stream urls contained in this file, it doesn't make sense to do
-            // for now, continue to use scheme and host from incoming requests
-            // string xmltvPath = Path.Combine(appDataFolder, "xmltv.xml");
-            // Log.Logger.Information("XMLTV is at {XmltvPath}", xmltvPath);
-
-            var connectionString = $"Data Source={FileSystemLayout.DatabasePath};foreign keys=true;";
-
-            services.AddDbContext<TvContext>(
-                options => options.UseSqlite(
-                    connectionString,
-                    o =>
-                    {
-                        o.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
-                        o.MigrationsAssembly("ErsatzTV.Infrastructure");
-                    }),
-                ServiceLifetime.Scoped,
-                ServiceLifetime.Singleton);
-
-            services.AddDbContextFactory<TvContext>(
-                options => options.UseSqlite(
-                    connectionString,
-                    o =>
-                    {
-                        o.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
-                        o.MigrationsAssembly("ErsatzTV.Infrastructure");
-                    }));
-            
-            services.AddTransient<IDbConnection>(_ => new SqliteConnection(connectionString));
-            SqlMapper.AddTypeHandler(new DateTimeOffsetHandler());
-            SqlMapper.AddTypeHandler(new GuidHandler());
-            SqlMapper.AddTypeHandler(new TimeSpanHandler());
-
-            var logConnectionString = $"Data Source={FileSystemLayout.LogDatabasePath}";
-            
-            services.AddDbContext<LogContext>(
-                options => options.UseSqlite(logConnectionString),
-                ServiceLifetime.Scoped,
-                ServiceLifetime.Singleton);
-
-            services.AddDbContextFactory<LogContext>(
-                options => options.UseSqlite(logConnectionString));
-
-            services.AddMediatR(typeof(GetAllChannels).Assembly);
-
-            services.AddRefitClient<IPlexTvApi>()
-                .ConfigureHttpClient(c => c.BaseAddress = new Uri("https://plex.tv/api/v2"));
-
-            services.AddRefitClient<ITraktApi>()
-                .ConfigureHttpClient(c => c.BaseAddress = new Uri("https://api.trakt.tv"));
-
-            services.Configure<TraktConfiguration>(Configuration.GetSection("Trakt"));
-
-            CustomServices(services);
-        }
-
-        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
-        {
-            app.UseCors("AllowAll");
-
-            // app.UseSerilogRequestLogging();
-
-            app.UseStaticFiles();
-
-            var extensionProvider = new FileExtensionContentTypeProvider();
-            extensionProvider.Mappings.Add(".m3u8", "application/vnd.apple.mpegurl");
-
-            app.UseStaticFiles(
-                new StaticFileOptions
+        services.AddCors(
+            o => o.AddPolicy(
+                "AllowAll",
+                builder =>
                 {
-                    FileProvider = new PhysicalFileProvider(FileSystemLayout.TranscodeFolder),
-                    RequestPath = "/iptv/session",
-                    ContentTypeProvider = extensionProvider,
-                    OnPrepareResponse = ctx =>
-                    {
-                        // Log.Logger.Information("Transcode access: {Test}", ctx.File.PhysicalPath);
-                        ChannelWriter<IFFmpegWorkerRequest> writer = app.ApplicationServices
-                            .GetRequiredService<ChannelWriter<IFFmpegWorkerRequest>>();
-                        writer.TryWrite(new TouchFFmpegSession(ctx.File.PhysicalPath));
-                    }
-                });
+                    builder.AllowAnyOrigin()
+                        .AllowAnyMethod()
+                        .AllowAnyHeader();
+                }));
 
-            app.UseRouting();
-
-            app.UseEndpoints(
-                endpoints =>
+        services.AddControllers(
+                options =>
                 {
-                    endpoints.MapControllers();
-                    endpoints.MapBlazorHub();
-                    endpoints.MapFallbackToPage("/_Host");
-                });
-        }
-
-        private void CustomServices(IServiceCollection services)
-        {
-            services.AddSingleton<FFmpegPlaybackSettingsCalculator>();
-            services.AddSingleton<IPlexSecretStore, PlexSecretStore>();
-            services.AddSingleton<IPlexTvApiClient, PlexTvApiClient>(); // TODO: does this need to be singleton?
-            services.AddSingleton<ITraktApiClient, TraktApiClient>();
-            services.AddSingleton<IEntityLocker, EntityLocker>();
-            services.AddSingleton<ISearchIndex, SearchIndex>();
-            services.AddSingleton<IFFmpegSegmenterService, FFmpegSegmenterService>();
-            services.AddSingleton<ITempFilePool, TempFilePool>();
-            services.AddSingleton<IHlsPlaylistFilter, HlsPlaylistFilter>();
-            AddChannel<IBackgroundServiceRequest>(services);
-            AddChannel<IPlexBackgroundServiceRequest>(services);
-            AddChannel<IJellyfinBackgroundServiceRequest>(services);
-            AddChannel<IEmbyBackgroundServiceRequest>(services);
-            AddChannel<IFFmpegWorkerRequest>(services);
-            
-            services.AddScoped<IFFmpegVersionHealthCheck, FFmpegVersionHealthCheck>();
-            services.AddScoped<IFFmpegReportsHealthCheck, FFmpegReportsHealthCheck>();
-            services.AddScoped<IHardwareAccelerationHealthCheck, HardwareAccelerationHealthCheck>();
-            services.AddScoped<IMovieMetadataHealthCheck, MovieMetadataHealthCheck>();
-            services.AddScoped<IEpisodeMetadataHealthCheck, EpisodeMetadataHealthCheck>();
-            services.AddScoped<IZeroDurationHealthCheck, ZeroDurationHealthCheck>();
-            services.AddScoped<IFileNotFoundHealthCheck, FileNotFoundHealthCheck>();
-            services.AddScoped<IVaapiDriverHealthCheck, VaapiDriverHealthCheck>();
-            services.AddScoped<IErrorReportsHealthCheck, ErrorReportsHealthCheck>();
-            services.AddScoped<IHealthCheckService, HealthCheckService>();
-
-            services.AddScoped<IChannelRepository, ChannelRepository>();
-            services.AddScoped<IFFmpegProfileRepository, FFmpegProfileRepository>();
-            services.AddScoped<IMediaSourceRepository, MediaSourceRepository>();
-            services.AddScoped<IMediaItemRepository, MediaItemRepository>();
-            services.AddScoped<IMediaCollectionRepository, MediaCollectionRepository>();
-            services.AddScoped<IConfigElementRepository, ConfigElementRepository>();
-            services.AddScoped<ITelevisionRepository, TelevisionRepository>();
-            services.AddScoped<ISearchRepository, SearchRepository>();
-            services.AddScoped<IMovieRepository, MovieRepository>();
-            services.AddScoped<IArtistRepository, ArtistRepository>();
-            services.AddScoped<IMusicVideoRepository, MusicVideoRepository>();
-            services.AddScoped<IOtherVideoRepository, OtherVideoRepository>();
-            services.AddScoped<ISongRepository, SongRepository>();
-            services.AddScoped<ILibraryRepository, LibraryRepository>();
-            services.AddScoped<IMetadataRepository, MetadataRepository>();
-            services.AddScoped<IArtworkRepository, ArtworkRepository>();
-            services.AddScoped<IFFmpegLocator, FFmpegLocator>();
-            services.AddScoped<ILocalMetadataProvider, LocalMetadataProvider>();
-            services.AddScoped<IFallbackMetadataProvider, FallbackMetadataProvider>();
-            services.AddScoped<ILocalStatisticsProvider, LocalStatisticsProvider>();
-            services.AddScoped<IPlayoutBuilder, PlayoutBuilder>();
-            services.AddScoped<IImageCache, ImageCache>();
-            services.AddScoped<ILocalFileSystem, LocalFileSystem>();
-            services.AddScoped<IMovieFolderScanner, MovieFolderScanner>();
-            services.AddScoped<ITelevisionFolderScanner, TelevisionFolderScanner>();
-            services.AddScoped<IMusicVideoFolderScanner, MusicVideoFolderScanner>();
-            services.AddScoped<IOtherVideoFolderScanner, OtherVideoFolderScanner>();
-            services.AddScoped<ISongFolderScanner, SongFolderScanner>();
-            services.AddScoped<IPlexMovieLibraryScanner, PlexMovieLibraryScanner>();
-            services.AddScoped<IPlexTelevisionLibraryScanner, PlexTelevisionLibraryScanner>();
-            services.AddScoped<IPlexServerApiClient, PlexServerApiClient>();
-            services.AddScoped<IJellyfinMovieLibraryScanner, JellyfinMovieLibraryScanner>();
-            services.AddScoped<IJellyfinTelevisionLibraryScanner, JellyfinTelevisionLibraryScanner>();
-            services.AddScoped<IJellyfinApiClient, JellyfinApiClient>();
-            services.AddScoped<IJellyfinPathReplacementService, JellyfinPathReplacementService>();
-            services.AddScoped<IJellyfinTelevisionRepository, JellyfinTelevisionRepository>();
-            services.AddScoped<IEmbyApiClient, EmbyApiClient>();
-            services.AddScoped<IEmbyMovieLibraryScanner, EmbyMovieLibraryScanner>();
-            services.AddScoped<IEmbyTelevisionLibraryScanner, EmbyTelevisionLibraryScanner>();
-            services.AddScoped<IEmbyPathReplacementService, EmbyPathReplacementService>();
-            services.AddScoped<IEmbyTelevisionRepository, EmbyTelevisionRepository>();
-            services.AddScoped<IRuntimeInfo, RuntimeInfo>();
-            services.AddScoped<IPlexPathReplacementService, PlexPathReplacementService>();
-            services.AddScoped<IFFmpegStreamSelector, FFmpegStreamSelector>();
-            
-            // services.AddScoped<IFFmpegProcessService, FFmpegProcessService>();
-            services.AddScoped<IFFmpegProcessServiceFactory, FFmpegProcessServiceFactory>();
-            services.AddScoped<FFmpegLibraryProcessService>();
-            services.AddScoped<FFmpegProcessService>();
-            
-            services.AddScoped<ISongVideoGenerator, SongVideoGenerator>();
-            services.AddScoped<HlsSessionWorker>();
-            services.AddScoped<IGitHubApiClient, GitHubApiClient>();
-            services.AddScoped<IHtmlSanitizer, HtmlSanitizer>(
-                _ =>
+                    options.OutputFormatters.Insert(0, new ConcatPlaylistOutputFormatter());
+                    options.OutputFormatters.Insert(0, new ChannelPlaylistOutputFormatter());
+                    options.OutputFormatters.Insert(0, new ChannelGuideOutputFormatter());
+                    options.OutputFormatters.Insert(0, new DeviceXmlOutputFormatter());
+                    options.OutputFormatters.Insert(0, new HdhrJsonOutputFormatter());
+                })
+            .AddNewtonsoftJson(
+                opt =>
                 {
-                    var sanitizer = new HtmlSanitizer();
-                    sanitizer.AllowedAttributes.Add("class");
-                    return sanitizer;
+                    opt.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
+                    opt.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
+                    opt.SerializerSettings.ContractResolver = new CustomContractResolver();
+                    opt.SerializerSettings.Converters.Add(new StringEnumConverter());
+                })
+            .AddFluentValidation(
+                options =>
+                {
+                    options.RegisterValidatorsFromAssemblyContaining<Startup>();
+                    options.ImplicitlyValidateChildProperties = true;
                 });
-            services.AddScoped<IJellyfinSecretStore, JellyfinSecretStore>();
-            services.AddScoped<IEmbySecretStore, EmbySecretStore>();
-            services.AddScoped<IEpisodeNfoReader, EpisodeNfoReader>();
 
-            // services.AddTransient(typeof(IRequestHandler<,>), typeof(GetRecentLogEntriesHandler<>));
+        services.AddRazorPages();
+        services.AddServerSideBlazor();
 
-            services.AddHostedService<EndpointValidatorService>();
-            services.AddHostedService<DatabaseMigratorService>();
-            services.AddHostedService<CacheCleanerService>();
-            services.AddHostedService<ResourceExtractorService>();
-            services.AddHostedService<PlatformSettingsService>();
-            services.AddHostedService<EmbyService>();
-            services.AddHostedService<JellyfinService>();
-            services.AddHostedService<PlexService>();
-            services.AddHostedService<FFmpegLocatorService>();
-            services.AddHostedService<WorkerService>();
-            services.AddHostedService<SchedulerService>();
-            services.AddHostedService<FFmpegWorkerService>();
-        }
+        services.AddMudServices();
 
-        private void AddChannel<TMessageType>(IServiceCollection services)
+        var coreAssembly = Assembly.GetAssembly(typeof(LibraryScanProgress));
+        if (coreAssembly != null)
         {
-            services.AddSingleton(
-                Channel.CreateUnbounded<TMessageType>(new UnboundedChannelOptions { SingleReader = true }));
-            services.AddSingleton(
-                provider => provider.GetRequiredService<Channel<TMessageType>>().Reader);
-            services.AddSingleton(
-                provider => provider.GetRequiredService<Channel<TMessageType>>().Writer);
+            services.AddCourier(coreAssembly);
         }
+
+        Console.OutputEncoding = Encoding.UTF8;
+
+        Log.Logger.Information(
+            "ErsatzTV version {Version}",
+            Assembly.GetEntryAssembly()?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
+                ?.InformationalVersion ?? "unknown");
+
+        Log.Logger.Warning("This is alpha software and is likely to be unstable");
+        Log.Logger.Warning(
+            "Give feedback at {GitHub} or {Discord}",
+            "https://github.com/jasongdove/ErsatzTV",
+            "https://discord.gg/hHaJm3yGy6");
+
+        if (!Directory.Exists(FileSystemLayout.AppDataFolder))
+        {
+            Directory.CreateDirectory(FileSystemLayout.AppDataFolder);
+        }
+
+        if (!Directory.Exists(FileSystemLayout.TranscodeFolder))
+        {
+            Directory.CreateDirectory(FileSystemLayout.TranscodeFolder);
+        }
+
+        if (!Directory.Exists(FileSystemLayout.TempFilePoolFolder))
+        {
+            Directory.CreateDirectory(FileSystemLayout.TempFilePoolFolder);
+        }
+
+        Log.Logger.Information("Database is at {DatabasePath}", FileSystemLayout.DatabasePath);
+
+        // until we add a setting for a file-specific scheme://host:port to access
+        // stream urls contained in this file, it doesn't make sense to do
+        // for now, continue to use scheme and host from incoming requests
+        // string xmltvPath = Path.Combine(appDataFolder, "xmltv.xml");
+        // Log.Logger.Information("XMLTV is at {XmltvPath}", xmltvPath);
+
+        var connectionString = $"Data Source={FileSystemLayout.DatabasePath};foreign keys=true;";
+
+        services.AddDbContext<TvContext>(
+            options => options.UseSqlite(
+                connectionString,
+                o =>
+                {
+                    o.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
+                    o.MigrationsAssembly("ErsatzTV.Infrastructure");
+                }),
+            ServiceLifetime.Scoped,
+            ServiceLifetime.Singleton);
+
+        services.AddDbContextFactory<TvContext>(
+            options => options.UseSqlite(
+                connectionString,
+                o =>
+                {
+                    o.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
+                    o.MigrationsAssembly("ErsatzTV.Infrastructure");
+                }));
+            
+        services.AddTransient<IDbConnection>(_ => new SqliteConnection(connectionString));
+        SqlMapper.AddTypeHandler(new DateTimeOffsetHandler());
+        SqlMapper.AddTypeHandler(new GuidHandler());
+        SqlMapper.AddTypeHandler(new TimeSpanHandler());
+
+        var logConnectionString = $"Data Source={FileSystemLayout.LogDatabasePath}";
+            
+        services.AddDbContext<LogContext>(
+            options => options.UseSqlite(logConnectionString),
+            ServiceLifetime.Scoped,
+            ServiceLifetime.Singleton);
+
+        services.AddDbContextFactory<LogContext>(
+            options => options.UseSqlite(logConnectionString));
+
+        services.AddMediatR(typeof(GetAllChannels).Assembly);
+
+        services.AddRefitClient<IPlexTvApi>()
+            .ConfigureHttpClient(c => c.BaseAddress = new Uri("https://plex.tv/api/v2"));
+
+        services.AddRefitClient<ITraktApi>()
+            .ConfigureHttpClient(c => c.BaseAddress = new Uri("https://api.trakt.tv"));
+
+        services.Configure<TraktConfiguration>(Configuration.GetSection("Trakt"));
+
+        CustomServices(services);
     }
-}
+
+    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+    {
+        app.UseCors("AllowAll");
+
+        // app.UseSerilogRequestLogging();
+
+        app.UseStaticFiles();
+
+        var extensionProvider = new FileExtensionContentTypeProvider();
+        extensionProvider.Mappings.Add(".m3u8", "application/vnd.apple.mpegurl");
+
+        app.UseStaticFiles(
+            new StaticFileOptions
+            {
+                FileProvider = new PhysicalFileProvider(FileSystemLayout.TranscodeFolder),
+                RequestPath = "/iptv/session",
+                ContentTypeProvider = extensionProvider,
+                OnPrepareResponse = ctx =>
+                {
+                    // Log.Logger.Information("Transcode access: {Test}", ctx.File.PhysicalPath);
+                    ChannelWriter<IFFmpegWorkerRequest> writer = app.ApplicationServices
+                        .GetRequiredService<ChannelWriter<IFFmpegWorkerRequest>>();
+                    writer.TryWrite(new TouchFFmpegSession(ctx.File.PhysicalPath));
+                }
+            });
+
+        app.UseRouting();
+
+        app.UseEndpoints(
+            endpoints =>
+            {
+                endpoints.MapControllers();
+                endpoints.MapBlazorHub();
+                endpoints.MapFallbackToPage("/_Host");
+            });
+    }
+
+    private void CustomServices(IServiceCollection services)
+    {
+        services.AddSingleton<FFmpegPlaybackSettingsCalculator>();
+        services.AddSingleton<IPlexSecretStore, PlexSecretStore>();
+        services.AddSingleton<IPlexTvApiClient, PlexTvApiClient>(); // TODO: does this need to be singleton?
+        services.AddSingleton<ITraktApiClient, TraktApiClient>();
+        services.AddSingleton<IEntityLocker, EntityLocker>();
+        services.AddSingleton<ISearchIndex, SearchIndex>();
+        services.AddSingleton<IFFmpegSegmenterService, FFmpegSegmenterService>();
+        services.AddSingleton<ITempFilePool, TempFilePool>();
+        services.AddSingleton<IHlsPlaylistFilter, HlsPlaylistFilter>();
+        AddChannel<IBackgroundServiceRequest>(services);
+        AddChannel<IPlexBackgroundServiceRequest>(services);
+        AddChannel<IJellyfinBackgroundServiceRequest>(services);
+        AddChannel<IEmbyBackgroundServiceRequest>(services);
+        AddChannel<IFFmpegWorkerRequest>(services);
+            
+        services.AddScoped<IFFmpegVersionHealthCheck, FFmpegVersionHealthCheck>();
+        services.AddScoped<IFFmpegReportsHealthCheck, FFmpegReportsHealthCheck>();
+        services.AddScoped<IHardwareAccelerationHealthCheck, HardwareAccelerationHealthCheck>();
+        services.AddScoped<IMovieMetadataHealthCheck, MovieMetadataHealthCheck>();
+        services.AddScoped<IEpisodeMetadataHealthCheck, EpisodeMetadataHealthCheck>();
+        services.AddScoped<IZeroDurationHealthCheck, ZeroDurationHealthCheck>();
+        services.AddScoped<IFileNotFoundHealthCheck, FileNotFoundHealthCheck>();
+        services.AddScoped<IVaapiDriverHealthCheck, VaapiDriverHealthCheck>();
+        services.AddScoped<IErrorReportsHealthCheck, ErrorReportsHealthCheck>();
+        services.AddScoped<IHealthCheckService, HealthCheckService>();
+
+        services.AddScoped<IChannelRepository, ChannelRepository>();
+        services.AddScoped<IFFmpegProfileRepository, FFmpegProfileRepository>();
+        services.AddScoped<IMediaSourceRepository, MediaSourceRepository>();
+        services.AddScoped<IMediaItemRepository, MediaItemRepository>();
+        services.AddScoped<IMediaCollectionRepository, MediaCollectionRepository>();
+        services.AddScoped<IConfigElementRepository, ConfigElementRepository>();
+        services.AddScoped<ITelevisionRepository, TelevisionRepository>();
+        services.AddScoped<ISearchRepository, SearchRepository>();
+        services.AddScoped<IMovieRepository, MovieRepository>();
+        services.AddScoped<IArtistRepository, ArtistRepository>();
+        services.AddScoped<IMusicVideoRepository, MusicVideoRepository>();
+        services.AddScoped<IOtherVideoRepository, OtherVideoRepository>();
+        services.AddScoped<ISongRepository, SongRepository>();
+        services.AddScoped<ILibraryRepository, LibraryRepository>();
+        services.AddScoped<IMetadataRepository, MetadataRepository>();
+        services.AddScoped<IArtworkRepository, ArtworkRepository>();
+        services.AddScoped<IFFmpegLocator, FFmpegLocator>();
+        services.AddScoped<ILocalMetadataProvider, LocalMetadataProvider>();
+        services.AddScoped<IFallbackMetadataProvider, FallbackMetadataProvider>();
+        services.AddScoped<ILocalStatisticsProvider, LocalStatisticsProvider>();
+        services.AddScoped<IPlayoutBuilder, PlayoutBuilder>();
+        services.AddScoped<IImageCache, ImageCache>();
+        services.AddScoped<ILocalFileSystem, LocalFileSystem>();
+        services.AddScoped<IMovieFolderScanner, MovieFolderScanner>();
+        services.AddScoped<ITelevisionFolderScanner, TelevisionFolderScanner>();
+        services.AddScoped<IMusicVideoFolderScanner, MusicVideoFolderScanner>();
+        services.AddScoped<IOtherVideoFolderScanner, OtherVideoFolderScanner>();
+        services.AddScoped<ISongFolderScanner, SongFolderScanner>();
+        services.AddScoped<IPlexMovieLibraryScanner, PlexMovieLibraryScanner>();
+        services.AddScoped<IPlexTelevisionLibraryScanner, PlexTelevisionLibraryScanner>();
+        services.AddScoped<IPlexServerApiClient, PlexServerApiClient>();
+        services.AddScoped<IJellyfinMovieLibraryScanner, JellyfinMovieLibraryScanner>();
+        services.AddScoped<IJellyfinTelevisionLibraryScanner, JellyfinTelevisionLibraryScanner>();
+        services.AddScoped<IJellyfinApiClient, JellyfinApiClient>();
+        services.AddScoped<IJellyfinPathReplacementService, JellyfinPathReplacementService>();
+        services.AddScoped<IJellyfinTelevisionRepository, JellyfinTelevisionRepository>();
+        services.AddScoped<IEmbyApiClient, EmbyApiClient>();
+        services.AddScoped<IEmbyMovieLibraryScanner, EmbyMovieLibraryScanner>();
+        services.AddScoped<IEmbyTelevisionLibraryScanner, EmbyTelevisionLibraryScanner>();
+        services.AddScoped<IEmbyPathReplacementService, EmbyPathReplacementService>();
+        services.AddScoped<IEmbyTelevisionRepository, EmbyTelevisionRepository>();
+        services.AddScoped<IRuntimeInfo, RuntimeInfo>();
+        services.AddScoped<IPlexPathReplacementService, PlexPathReplacementService>();
+        services.AddScoped<IFFmpegStreamSelector, FFmpegStreamSelector>();
+            
+        // services.AddScoped<IFFmpegProcessService, FFmpegProcessService>();
+        services.AddScoped<IFFmpegProcessServiceFactory, FFmpegProcessServiceFactory>();
+        services.AddScoped<FFmpegLibraryProcessService>();
+        services.AddScoped<FFmpegProcessService>();
+            
+        services.AddScoped<ISongVideoGenerator, SongVideoGenerator>();
+        services.AddScoped<HlsSessionWorker>();
+        services.AddScoped<IGitHubApiClient, GitHubApiClient>();
+        services.AddScoped<IHtmlSanitizer, HtmlSanitizer>(
+            _ =>
+            {
+                var sanitizer = new HtmlSanitizer();
+                sanitizer.AllowedAttributes.Add("class");
+                return sanitizer;
+            });
+        services.AddScoped<IJellyfinSecretStore, JellyfinSecretStore>();
+        services.AddScoped<IEmbySecretStore, EmbySecretStore>();
+        services.AddScoped<IEpisodeNfoReader, EpisodeNfoReader>();
+
+        // services.AddTransient(typeof(IRequestHandler<,>), typeof(GetRecentLogEntriesHandler<>));
+
+        services.AddHostedService<EndpointValidatorService>();
+        services.AddHostedService<DatabaseMigratorService>();
+        services.AddHostedService<CacheCleanerService>();
+        services.AddHostedService<ResourceExtractorService>();
+        services.AddHostedService<PlatformSettingsService>();
+        services.AddHostedService<EmbyService>();
+        services.AddHostedService<JellyfinService>();
+        services.AddHostedService<PlexService>();
+        services.AddHostedService<FFmpegLocatorService>();
+        services.AddHostedService<WorkerService>();
+        services.AddHostedService<SchedulerService>();
+        services.AddHostedService<FFmpegWorkerService>();
+    }
+
+    private void AddChannel<TMessageType>(IServiceCollection services)
+    {
+        services.AddSingleton(
+            Channel.CreateUnbounded<TMessageType>(new UnboundedChannelOptions { SingleReader = true }));
+        services.AddSingleton(
+            provider => provider.GetRequiredService<Channel<TMessageType>>().Reader);
+        services.AddSingleton(
+            provider => provider.GetRequiredService<Channel<TMessageType>>().Writer);
+    }
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/ChannelEditViewModelValidator.cs b/ErsatzTV/Validators/ChannelEditViewModelValidator.cs
index c718aeeb6..53ba432ed 100644
--- a/ErsatzTV/Validators/ChannelEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/ChannelEditViewModelValidator.cs
@@ -1,33 +1,30 @@
-using System;
-using System.Globalization;
-using System.Linq;
+using System.Globalization;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class ChannelEditViewModelValidator : AbstractValidator<ChannelEditViewModel>
 {
-    public class ChannelEditViewModelValidator : AbstractValidator<ChannelEditViewModel>
+    public ChannelEditViewModelValidator()
     {
-        public ChannelEditViewModelValidator()
-        {
-            RuleFor(x => x.Number).Matches(Channel.NumberValidator)
-                .WithMessage("Invalid channel number; one decimal is allowed for subchannels");
+        RuleFor(x => x.Number).Matches(Channel.NumberValidator)
+            .WithMessage("Invalid channel number; one decimal is allowed for subchannels");
 
-            RuleFor(x => x.Name).NotEmpty();
-            RuleFor(x => x.Group).NotEmpty();
-            RuleFor(x => x.FFmpegProfileId).GreaterThan(0);
+        RuleFor(x => x.Name).NotEmpty();
+        RuleFor(x => x.Group).NotEmpty();
+        RuleFor(x => x.FFmpegProfileId).GreaterThan(0);
 
-            RuleFor(x => x.PreferredLanguageCode)
-                .Must(
-                    languageCode => CultureInfo.GetCultures(CultureTypes.NeutralCultures)
-                        .Any(
-                            ci => string.Equals(
-                                ci.ThreeLetterISOLanguageName,
-                                languageCode,
-                                StringComparison.OrdinalIgnoreCase)))
-                .When(vm => !string.IsNullOrWhiteSpace(vm.PreferredLanguageCode))
-                .WithMessage("Preferred language code is invalid");
-        }
+        RuleFor(x => x.PreferredLanguageCode)
+            .Must(
+                languageCode => CultureInfo.GetCultures(CultureTypes.NeutralCultures)
+                    .Any(
+                        ci => string.Equals(
+                            ci.ThreeLetterISOLanguageName,
+                            languageCode,
+                            StringComparison.OrdinalIgnoreCase)))
+            .When(vm => !string.IsNullOrWhiteSpace(vm.PreferredLanguageCode))
+            .WithMessage("Preferred language code is invalid");
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/CollectionEditViewModelValidator.cs b/ErsatzTV/Validators/CollectionEditViewModelValidator.cs
index e8e878799..791c9c573 100644
--- a/ErsatzTV/Validators/CollectionEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/CollectionEditViewModelValidator.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class CollectionEditViewModelValidator : AbstractValidator<CollectionEditViewModel>
 {
-    public class CollectionEditViewModelValidator : AbstractValidator<CollectionEditViewModel>
-    {
-        public CollectionEditViewModelValidator() => RuleFor(c => c.Name).NotEmpty();
-    }
-}
+    public CollectionEditViewModelValidator() => RuleFor(c => c.Name).NotEmpty();
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/FFmpegProfileEditViewModelValidator.cs b/ErsatzTV/Validators/FFmpegProfileEditViewModelValidator.cs
index a4288d4ea..45c2dff40 100644
--- a/ErsatzTV/Validators/FFmpegProfileEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/FFmpegProfileEditViewModelValidator.cs
@@ -1,76 +1,74 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class FFmpegProfileEditViewModelValidator : AbstractValidator<FFmpegProfileEditViewModel>
 {
-    public class FFmpegProfileEditViewModelValidator : AbstractValidator<FFmpegProfileEditViewModel>
+    private static readonly List<string> QsvEncoders = new() { "h264_qsv", "hevc_qsv", "mpeg2_qsv" };
+    private static readonly List<string> NvencEncoders = new() { "h264_nvenc", "hevc_nvenc" };
+    private static readonly List<string> VaapiEncoders = new() { "h264_vaapi", "hevc_vaapi", "mpeg2_vaapi" };
+    private static readonly List<string> VideoToolboxEncoders = new() { "h264_videotoolbox", "hevc_videotoolbox" };
+
+    public FFmpegProfileEditViewModelValidator()
     {
-        private static readonly List<string> QsvEncoders = new() { "h264_qsv", "hevc_qsv", "mpeg2_qsv" };
-        private static readonly List<string> NvencEncoders = new() { "h264_nvenc", "hevc_nvenc" };
-        private static readonly List<string> VaapiEncoders = new() { "h264_vaapi", "hevc_vaapi", "mpeg2_vaapi" };
-        private static readonly List<string> VideoToolboxEncoders = new() { "h264_videotoolbox", "hevc_videotoolbox" };
+        RuleFor(x => x.Name).NotEmpty();
+        RuleFor(x => x.ThreadCount).GreaterThanOrEqualTo(0);
 
-        public FFmpegProfileEditViewModelValidator()
-        {
-            RuleFor(x => x.Name).NotEmpty();
-            RuleFor(x => x.ThreadCount).GreaterThanOrEqualTo(0);
+        When(
+            x => x.Transcode,
+            () =>
+            {
+                RuleFor(x => x.VideoCodec).NotEmpty();
+                RuleFor(x => x.VideoBitrate).GreaterThan(0);
+                RuleFor(x => x.VideoBufferSize).GreaterThan(0);
 
-            When(
-                x => x.Transcode,
-                () =>
-                {
-                    RuleFor(x => x.VideoCodec).NotEmpty();
-                    RuleFor(x => x.VideoBitrate).GreaterThan(0);
-                    RuleFor(x => x.VideoBufferSize).GreaterThan(0);
+                RuleFor(x => x.AudioCodec).NotEmpty();
+                RuleFor(x => x.AudioBitrate).GreaterThan(0);
+                RuleFor(x => x.AudioChannels).GreaterThan(0);
+            });
 
-                    RuleFor(x => x.AudioCodec).NotEmpty();
-                    RuleFor(x => x.AudioBitrate).GreaterThan(0);
-                    RuleFor(x => x.AudioChannels).GreaterThan(0);
-                });
+        When(
+            x => x.HardwareAcceleration == HardwareAccelerationKind.Qsv,
+            () =>
+            {
+                RuleFor(x => x.VideoCodec).Must(c => QsvEncoders.Contains(c))
+                    .WithMessage("QSV codec is required (h264_qsv, hevc_qsv, mpeg2_qsv)");
+            });
 
-            When(
-                x => x.HardwareAcceleration == HardwareAccelerationKind.Qsv,
-                () =>
-                {
-                    RuleFor(x => x.VideoCodec).Must(c => QsvEncoders.Contains(c))
-                        .WithMessage("QSV codec is required (h264_qsv, hevc_qsv, mpeg2_qsv)");
-                });
+        When(
+            x => x.HardwareAcceleration == HardwareAccelerationKind.Nvenc,
+            () =>
+            {
+                RuleFor(x => x.VideoCodec).Must(c => NvencEncoders.Contains(c))
+                    .WithMessage("NVENC codec is required (h264_nvenc, hevc_nvenc)");
+            });
 
-            When(
-                x => x.HardwareAcceleration == HardwareAccelerationKind.Nvenc,
-                () =>
-                {
-                    RuleFor(x => x.VideoCodec).Must(c => NvencEncoders.Contains(c))
-                        .WithMessage("NVENC codec is required (h264_nvenc, hevc_nvenc)");
-                });
+        When(
+            x => x.HardwareAcceleration == HardwareAccelerationKind.Vaapi,
+            () =>
+            {
+                RuleFor(x => x.VideoCodec).Must(c => VaapiEncoders.Contains(c))
+                    .WithMessage("VAAPI codec is required (h264_vaapi, hevc_vaapi, mpeg2_vaapi)");
+            });
 
-            When(
-                x => x.HardwareAcceleration == HardwareAccelerationKind.Vaapi,
-                () =>
-                {
-                    RuleFor(x => x.VideoCodec).Must(c => VaapiEncoders.Contains(c))
-                        .WithMessage("VAAPI codec is required (h264_vaapi, hevc_vaapi, mpeg2_vaapi)");
-                });
+        When(
+            x => x.HardwareAcceleration == HardwareAccelerationKind.VideoToolbox,
+            () =>
+            {
+                RuleFor(x => x.VideoCodec).Must(c => VideoToolboxEncoders.Contains(c))
+                    .WithMessage("VideoToolbox codec is required (h264_videotoolbox, hevc_videotoolbox)");
+            });
 
-            When(
-                x => x.HardwareAcceleration == HardwareAccelerationKind.VideoToolbox,
-                () =>
-                {
-                    RuleFor(x => x.VideoCodec).Must(c => VideoToolboxEncoders.Contains(c))
-                        .WithMessage("VideoToolbox codec is required (h264_videotoolbox, hevc_videotoolbox)");
-                });
-
-            When(
-                x => x.HardwareAcceleration == HardwareAccelerationKind.None,
-                () =>
-                {
-                    RuleFor(x => x.VideoCodec).Must(
-                            c => !QsvEncoders.Contains(c) && !NvencEncoders.Contains(c) && !VaapiEncoders.Contains(c) &&
-                                 !VideoToolboxEncoders.Contains(c))
-                        .WithMessage("Hardware acceleration is required for this codec");
-                });
-        }
+        When(
+            x => x.HardwareAcceleration == HardwareAccelerationKind.None,
+            () =>
+            {
+                RuleFor(x => x.VideoCodec).Must(
+                        c => !QsvEncoders.Contains(c) && !NvencEncoders.Contains(c) && !VaapiEncoders.Contains(c) &&
+                             !VideoToolboxEncoders.Contains(c))
+                    .WithMessage("Hardware acceleration is required for this codec");
+            });
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/FillerPresetEditViewModelValidator.cs b/ErsatzTV/Validators/FillerPresetEditViewModelValidator.cs
index dae636883..554d40188 100644
--- a/ErsatzTV/Validators/FillerPresetEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/FillerPresetEditViewModelValidator.cs
@@ -3,38 +3,37 @@ using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
-{
-    public class FillerPresetEditViewModelValidator : AbstractValidator<FillerPresetEditViewModel>
-    {
-        public FillerPresetEditViewModelValidator()
-        {
-            RuleFor(fp => fp.Name).NotEmpty();
-            RuleFor(fp => fp.FillerKind).NotEqual(FillerKind.None);
-        
-            When(
-                fp => fp.FillerKind != FillerKind.Fallback && fp.FillerKind != FillerKind.Tail,
-                () => RuleFor(fp => fp.FillerMode).NotEqual(FillerMode.None));
-            When(
-                fp => fp.FillerMode == FillerMode.Count,
-                () => RuleFor(fp => fp.Count).NotNull().GreaterThanOrEqualTo(0));
-            When(
-                fp => fp.FillerMode == FillerMode.Duration,
-                () => RuleFor(fp => fp.Duration).NotNull());
+namespace ErsatzTV.Validators;
 
-            When(
-                fp => fp.CollectionType == ProgramScheduleItemCollectionType.Collection,
-                () => RuleFor(fp => fp.Collection).NotNull());
-            When(
-                fp => fp.CollectionType == ProgramScheduleItemCollectionType.MultiCollection,
-                () => RuleFor(fp => fp.MultiCollection).NotNull());
-            When(
-                fp => fp.CollectionType == ProgramScheduleItemCollectionType.SmartCollection,
-                () => RuleFor(fp => fp.SmartCollection).NotNull());
-            When(
-                fp => fp.CollectionType is ProgramScheduleItemCollectionType.Artist or ProgramScheduleItemCollectionType
-                    .TelevisionShow or ProgramScheduleItemCollectionType.TelevisionSeason,
-                () => RuleFor(fp => fp.MediaItem).NotNull());
-        }
+public class FillerPresetEditViewModelValidator : AbstractValidator<FillerPresetEditViewModel>
+{
+    public FillerPresetEditViewModelValidator()
+    {
+        RuleFor(fp => fp.Name).NotEmpty();
+        RuleFor(fp => fp.FillerKind).NotEqual(FillerKind.None);
+        
+        When(
+            fp => fp.FillerKind != FillerKind.Fallback && fp.FillerKind != FillerKind.Tail,
+            () => RuleFor(fp => fp.FillerMode).NotEqual(FillerMode.None));
+        When(
+            fp => fp.FillerMode == FillerMode.Count,
+            () => RuleFor(fp => fp.Count).NotNull().GreaterThanOrEqualTo(0));
+        When(
+            fp => fp.FillerMode == FillerMode.Duration,
+            () => RuleFor(fp => fp.Duration).NotNull());
+
+        When(
+            fp => fp.CollectionType == ProgramScheduleItemCollectionType.Collection,
+            () => RuleFor(fp => fp.Collection).NotNull());
+        When(
+            fp => fp.CollectionType == ProgramScheduleItemCollectionType.MultiCollection,
+            () => RuleFor(fp => fp.MultiCollection).NotNull());
+        When(
+            fp => fp.CollectionType == ProgramScheduleItemCollectionType.SmartCollection,
+            () => RuleFor(fp => fp.SmartCollection).NotNull());
+        When(
+            fp => fp.CollectionType is ProgramScheduleItemCollectionType.Artist or ProgramScheduleItemCollectionType
+                .TelevisionShow or ProgramScheduleItemCollectionType.TelevisionSeason,
+            () => RuleFor(fp => fp.MediaItem).NotNull());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/LocalLibraryEditViewModelValidator.cs b/ErsatzTV/Validators/LocalLibraryEditViewModelValidator.cs
index 15ec20608..d8ed1c90d 100644
--- a/ErsatzTV/Validators/LocalLibraryEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/LocalLibraryEditViewModelValidator.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class LocalLibraryEditViewModelValidator : AbstractValidator<LocalLibraryEditViewModel>
 {
-    public class LocalLibraryEditViewModelValidator : AbstractValidator<LocalLibraryEditViewModel>
-    {
-        public LocalLibraryEditViewModelValidator() => RuleFor(c => c.Name).NotEmpty();
-    }
-}
+    public LocalLibraryEditViewModelValidator() => RuleFor(c => c.Name).NotEmpty();
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/LocalLibraryPathEditViewModelValidator.cs b/ErsatzTV/Validators/LocalLibraryPathEditViewModelValidator.cs
index f9b7b9326..9dc95936f 100644
--- a/ErsatzTV/Validators/LocalLibraryPathEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/LocalLibraryPathEditViewModelValidator.cs
@@ -1,15 +1,13 @@
-using System.IO;
-using ErsatzTV.ViewModels;
+using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class LocalLibraryPathEditViewModelValidator : AbstractValidator<LocalLibraryPathEditViewModel>
 {
-    public class LocalLibraryPathEditViewModelValidator : AbstractValidator<LocalLibraryPathEditViewModel>
+    public LocalLibraryPathEditViewModelValidator()
     {
-        public LocalLibraryPathEditViewModelValidator()
-        {
-            RuleFor(x => x.Path).NotEmpty();
-            RuleFor(x => x.Path).Must(Directory.Exists).WithMessage("Path must exist on filesystem");
-        }
+        RuleFor(x => x.Path).NotEmpty();
+        RuleFor(x => x.Path).Must(Directory.Exists).WithMessage("Path must exist on filesystem");
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/MultiCollectionEditViewModelValidator.cs b/ErsatzTV/Validators/MultiCollectionEditViewModelValidator.cs
index cdd9616fb..841001a03 100644
--- a/ErsatzTV/Validators/MultiCollectionEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/MultiCollectionEditViewModelValidator.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class MultiCollectionEditViewModelValidator : AbstractValidator<MultiCollectionEditViewModel>
 {
-    public class MultiCollectionEditViewModelValidator : AbstractValidator<MultiCollectionEditViewModel>
-    {
-        public MultiCollectionEditViewModelValidator() => RuleFor(c => c.Name).NotEmpty();
-    }
-}
+    public MultiCollectionEditViewModelValidator() => RuleFor(c => c.Name).NotEmpty();
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/PlayoutEditViewModelValidator.cs b/ErsatzTV/Validators/PlayoutEditViewModelValidator.cs
index 607ed375c..a4de39024 100644
--- a/ErsatzTV/Validators/PlayoutEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/PlayoutEditViewModelValidator.cs
@@ -1,14 +1,13 @@
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class PlayoutEditViewModelValidator : AbstractValidator<PlayoutEditViewModel>
 {
-    public class PlayoutEditViewModelValidator : AbstractValidator<PlayoutEditViewModel>
+    public PlayoutEditViewModelValidator()
     {
-        public PlayoutEditViewModelValidator()
-        {
-            RuleFor(p => p.Channel).NotNull();
-            RuleFor(p => p.ProgramSchedule).NotNull();
-        }
+        RuleFor(p => p.Channel).NotNull();
+        RuleFor(p => p.ProgramSchedule).NotNull();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/PlexPathReplacementEditViewModelValidator.cs b/ErsatzTV/Validators/PlexPathReplacementEditViewModelValidator.cs
index 0b84aa0ea..33871be21 100644
--- a/ErsatzTV/Validators/PlexPathReplacementEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/PlexPathReplacementEditViewModelValidator.cs
@@ -1,14 +1,13 @@
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class PlexPathReplacementEditViewModelValidator : AbstractValidator<PlexPathReplacementEditViewModel>
 {
-    public class PlexPathReplacementEditViewModelValidator : AbstractValidator<PlexPathReplacementEditViewModel>
+    public PlexPathReplacementEditViewModelValidator()
     {
-        public PlexPathReplacementEditViewModelValidator()
-        {
-            RuleFor(vm => vm.PlexPath).NotEmpty();
-            RuleFor(vm => vm.LocalPath).NotEmpty();
-        }
+        RuleFor(vm => vm.PlexPath).NotEmpty();
+        RuleFor(vm => vm.LocalPath).NotEmpty();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/ProgramScheduleEditViewModelValidator.cs b/ErsatzTV/Validators/ProgramScheduleEditViewModelValidator.cs
index 40d36f00e..cddd221bf 100644
--- a/ErsatzTV/Validators/ProgramScheduleEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/ProgramScheduleEditViewModelValidator.cs
@@ -1,10 +1,9 @@
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class ProgramScheduleEditViewModelValidator : AbstractValidator<ProgramScheduleEditViewModel>
 {
-    public class ProgramScheduleEditViewModelValidator : AbstractValidator<ProgramScheduleEditViewModel>
-    {
-        public ProgramScheduleEditViewModelValidator() => RuleFor(vm => vm.Name).NotEmpty();
-    }
-}
+    public ProgramScheduleEditViewModelValidator() => RuleFor(vm => vm.Name).NotEmpty();
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/ProgramScheduleItemEditViewModelValidator.cs b/ErsatzTV/Validators/ProgramScheduleItemEditViewModelValidator.cs
index 53d504263..c6cd72fa6 100644
--- a/ErsatzTV/Validators/ProgramScheduleItemEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/ProgramScheduleItemEditViewModelValidator.cs
@@ -2,21 +2,20 @@
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class ProgramScheduleItemEditViewModelValidator : AbstractValidator<ProgramScheduleItemEditViewModel>
 {
-    public class ProgramScheduleItemEditViewModelValidator : AbstractValidator<ProgramScheduleItemEditViewModel>
+    public ProgramScheduleItemEditViewModelValidator()
     {
-        public ProgramScheduleItemEditViewModelValidator()
-        {
-            When(
-                i => i.StartType == StartType.Fixed,
-                () => RuleFor(i => i.StartTime).NotNull());
-            When(
-                i => i.PlayoutMode == PlayoutMode.Multiple,
-                () => RuleFor(i => i.MultipleCount).NotNull().GreaterThanOrEqualTo(0));
-            When(
-                i => i.PlayoutMode == PlayoutMode.Duration,
-                () => RuleFor(i => i.PlayoutDuration).NotNull());
-        }
+        When(
+            i => i.StartType == StartType.Fixed,
+            () => RuleFor(i => i.StartTime).NotNull());
+        When(
+            i => i.PlayoutMode == PlayoutMode.Multiple,
+            () => RuleFor(i => i.MultipleCount).NotNull().GreaterThanOrEqualTo(0));
+        When(
+            i => i.PlayoutMode == PlayoutMode.Duration,
+            () => RuleFor(i => i.PlayoutDuration).NotNull());
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/RemoteMediaSourceEditViewModelValidator.cs b/ErsatzTV/Validators/RemoteMediaSourceEditViewModelValidator.cs
index 14810fbc4..85bc0887d 100644
--- a/ErsatzTV/Validators/RemoteMediaSourceEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/RemoteMediaSourceEditViewModelValidator.cs
@@ -1,20 +1,18 @@
-using System;
-using ErsatzTV.ViewModels;
+using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
-{
-    public class RemoteMediaSourceEditViewModelValidator : AbstractValidator<RemoteMediaSourceEditViewModel>
-    {
-        public RemoteMediaSourceEditViewModelValidator()
-        {
-            RuleFor(x => x.Address)
-                .NotEmpty()
-                .Must(uri => Uri.TryCreate(uri, UriKind.Absolute, out _))
-                .WithMessage("'Address' must be a valid URL");
+namespace ErsatzTV.Validators;
 
-            RuleFor(x => x.ApiKey)
-                .NotEmpty();
-        }
+public class RemoteMediaSourceEditViewModelValidator : AbstractValidator<RemoteMediaSourceEditViewModel>
+{
+    public RemoteMediaSourceEditViewModelValidator()
+    {
+        RuleFor(x => x.Address)
+            .NotEmpty()
+            .Must(uri => Uri.TryCreate(uri, UriKind.Absolute, out _))
+            .WithMessage("'Address' must be a valid URL");
+
+        RuleFor(x => x.ApiKey)
+            .NotEmpty();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/RemoteMediaSourcePathReplacementEditViewModelValidator.cs b/ErsatzTV/Validators/RemoteMediaSourcePathReplacementEditViewModelValidator.cs
index 39465f03c..fc43b40bd 100644
--- a/ErsatzTV/Validators/RemoteMediaSourcePathReplacementEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/RemoteMediaSourcePathReplacementEditViewModelValidator.cs
@@ -1,16 +1,15 @@
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class
+    RemoteMediaSourcePathReplacementEditViewModelValidator : AbstractValidator<
+        RemoteMediaSourcePathReplacementEditViewModel>
 {
-    public class
-        RemoteMediaSourcePathReplacementEditViewModelValidator : AbstractValidator<
-            RemoteMediaSourcePathReplacementEditViewModel>
+    public RemoteMediaSourcePathReplacementEditViewModelValidator()
     {
-        public RemoteMediaSourcePathReplacementEditViewModelValidator()
-        {
-            RuleFor(vm => vm.RemotePath).NotEmpty();
-            RuleFor(vm => vm.LocalPath).NotEmpty();
-        }
+        RuleFor(vm => vm.RemotePath).NotEmpty();
+        RuleFor(vm => vm.LocalPath).NotEmpty();
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/Validators/WatermarkEditViewModelValidator.cs b/ErsatzTV/Validators/WatermarkEditViewModelValidator.cs
index dd6b6bd38..acbe303c3 100644
--- a/ErsatzTV/Validators/WatermarkEditViewModelValidator.cs
+++ b/ErsatzTV/Validators/WatermarkEditViewModelValidator.cs
@@ -3,45 +3,44 @@ using ErsatzTV.FFmpeg.State;
 using ErsatzTV.ViewModels;
 using FluentValidation;
 
-namespace ErsatzTV.Validators
+namespace ErsatzTV.Validators;
+
+public class WatermarkEditViewModelValidator : AbstractValidator<WatermarkEditViewModel>
 {
-    public class WatermarkEditViewModelValidator : AbstractValidator<WatermarkEditViewModel>
+    public WatermarkEditViewModelValidator()
     {
-        public WatermarkEditViewModelValidator()
-        {
-            RuleFor(x => x.Name).NotEmpty();
+        RuleFor(x => x.Name).NotEmpty();
 
-            RuleFor(x => x.Image)
-                .NotEmpty()
-                .WithMessage("Watermark image is required!")
-                .When(vm => vm.ImageSource == ChannelWatermarkImageSource.Custom);
+        RuleFor(x => x.Image)
+            .NotEmpty()
+            .WithMessage("Watermark image is required!")
+            .When(vm => vm.ImageSource == ChannelWatermarkImageSource.Custom);
             
-            RuleFor(x => x.Width)
-                .GreaterThan(0)
-                .LessThanOrEqualTo(100)
-                .When(
-                    vm => vm.Mode != ChannelWatermarkMode.None &&
-                          vm.Size == WatermarkSize.Scaled);
+        RuleFor(x => x.Width)
+            .GreaterThan(0)
+            .LessThanOrEqualTo(100)
+            .When(
+                vm => vm.Mode != ChannelWatermarkMode.None &&
+                      vm.Size == WatermarkSize.Scaled);
 
-            RuleFor(x => x.HorizontalMargin)
-                .GreaterThanOrEqualTo(0)
-                .LessThanOrEqualTo(50)
-                .When(vm => vm.Mode != ChannelWatermarkMode.None);
+        RuleFor(x => x.HorizontalMargin)
+            .GreaterThanOrEqualTo(0)
+            .LessThanOrEqualTo(50)
+            .When(vm => vm.Mode != ChannelWatermarkMode.None);
 
-            RuleFor(x => x.VerticalMargin)
-                .GreaterThanOrEqualTo(0)
-                .LessThanOrEqualTo(50)
-                .When(vm => vm.Mode != ChannelWatermarkMode.None);
+        RuleFor(x => x.VerticalMargin)
+            .GreaterThanOrEqualTo(0)
+            .LessThanOrEqualTo(50)
+            .When(vm => vm.Mode != ChannelWatermarkMode.None);
 
-            RuleFor(x => x.DurationSeconds)
-                .GreaterThan(0)
-                .LessThan(c => c.FrequencyMinutes * 60)
-                .When(vm => vm.Mode != ChannelWatermarkMode.None);
+        RuleFor(x => x.DurationSeconds)
+            .GreaterThan(0)
+            .LessThan(c => c.FrequencyMinutes * 60)
+            .When(vm => vm.Mode != ChannelWatermarkMode.None);
 
-            RuleFor(x => x.Opacity)
-                .GreaterThan(0)
-                .LessThanOrEqualTo(100)
-                .When(vm => vm.Mode != ChannelWatermarkMode.None);
-        }
+        RuleFor(x => x.Opacity)
+            .GreaterThan(0)
+            .LessThanOrEqualTo(100)
+            .When(vm => vm.Mode != ChannelWatermarkMode.None);
     }
-}
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/ChannelEditViewModel.cs b/ErsatzTV/ViewModels/ChannelEditViewModel.cs
index 3f87ce1dd..fb427fe55 100644
--- a/ErsatzTV/ViewModels/ChannelEditViewModel.cs
+++ b/ErsatzTV/ViewModels/ChannelEditViewModel.cs
@@ -1,47 +1,46 @@
-using ErsatzTV.Application.Channels.Commands;
+using ErsatzTV.Application.Channels;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class ChannelEditViewModel
 {
-    public class ChannelEditViewModel
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public string Group { get; set; }
-        public string Categories { get; set; }
-        public string Number { get; set; }
-        public int FFmpegProfileId { get; set; }
-        public string PreferredLanguageCode { get; set; }
-        public string Logo { get; set; }
-        public StreamingMode StreamingMode { get; set; }
-        public int? WatermarkId { get; set; }
-        public int? FallbackFillerId { get; set; }
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public string Group { get; set; }
+    public string Categories { get; set; }
+    public string Number { get; set; }
+    public int FFmpegProfileId { get; set; }
+    public string PreferredLanguageCode { get; set; }
+    public string Logo { get; set; }
+    public StreamingMode StreamingMode { get; set; }
+    public int? WatermarkId { get; set; }
+    public int? FallbackFillerId { get; set; }
 
-        public UpdateChannel ToUpdate() =>
-            new(
-                Id,
-                Name,
-                Number,
-                Group,
-                Categories,
-                FFmpegProfileId,
-                Logo,
-                PreferredLanguageCode,
-                StreamingMode,
-                WatermarkId,
-                FallbackFillerId);
+    public UpdateChannel ToUpdate() =>
+        new(
+            Id,
+            Name,
+            Number,
+            Group,
+            Categories,
+            FFmpegProfileId,
+            Logo,
+            PreferredLanguageCode,
+            StreamingMode,
+            WatermarkId,
+            FallbackFillerId);
 
-        public CreateChannel ToCreate() =>
-            new(
-                Name,
-                Number,
-                Group,
-                Categories,
-                FFmpegProfileId,
-                Logo,
-                PreferredLanguageCode,
-                StreamingMode,
-                WatermarkId,
-                FallbackFillerId);
-    }
-}
+    public CreateChannel ToCreate() =>
+        new(
+            Name,
+            Number,
+            Group,
+            Categories,
+            FFmpegProfileId,
+            Logo,
+            PreferredLanguageCode,
+            StreamingMode,
+            WatermarkId,
+            FallbackFillerId);
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/CollectionEditViewModel.cs b/ErsatzTV/ViewModels/CollectionEditViewModel.cs
index 6d4ba6df4..a208118d3 100644
--- a/ErsatzTV/ViewModels/CollectionEditViewModel.cs
+++ b/ErsatzTV/ViewModels/CollectionEditViewModel.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class CollectionEditViewModel
 {
-    public class CollectionEditViewModel
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/FFmpegProfileEditViewModel.cs b/ErsatzTV/ViewModels/FFmpegProfileEditViewModel.cs
index e8e4e24cc..1a9b6a462 100644
--- a/ErsatzTV/ViewModels/FFmpegProfileEditViewModel.cs
+++ b/ErsatzTV/ViewModels/FFmpegProfileEditViewModel.cs
@@ -1,107 +1,105 @@
 using ErsatzTV.Application.FFmpegProfiles;
-using ErsatzTV.Application.FFmpegProfiles.Commands;
 using ErsatzTV.Application.Resolutions;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.FFmpeg;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class FFmpegProfileEditViewModel
 {
-    public class FFmpegProfileEditViewModel
+    public FFmpegProfileEditViewModel()
     {
-        public FFmpegProfileEditViewModel()
-        {
-        }
-
-        public FFmpegProfileEditViewModel(FFmpegProfileViewModel viewModel)
-        {
-            AudioBitrate = viewModel.AudioBitrate;
-            AudioBufferSize = viewModel.AudioBufferSize;
-            AudioChannels = viewModel.AudioChannels;
-            AudioCodec = viewModel.AudioCodec;
-            AudioSampleRate = viewModel.AudioSampleRate;
-            NormalizeLoudness = viewModel.NormalizeLoudness;
-            Id = viewModel.Id;
-            Name = viewModel.Name;
-            NormalizeAudio = viewModel.NormalizeAudio;
-            NormalizeVideo = viewModel.NormalizeVideo;
-            NormalizeFramerate = viewModel.NormalizeFramerate;
-            Resolution = viewModel.Resolution;
-            ThreadCount = viewModel.ThreadCount;
-            Transcode = viewModel.Transcode;
-            HardwareAcceleration = viewModel.HardwareAcceleration;
-            VaapiDriver = viewModel.VaapiDriver;
-            VaapiDevice = viewModel.VaapiDevice;
-            VideoBitrate = viewModel.VideoBitrate;
-            VideoBufferSize = viewModel.VideoBufferSize;
-            VideoCodec = viewModel.VideoCodec;
-        }
-
-        public int AudioBitrate { get; set; }
-        public int AudioBufferSize { get; set; }
-        public int AudioChannels { get; set; }
-        public string AudioCodec { get; set; }
-        public int AudioSampleRate { get; set; }
-        public bool NormalizeLoudness { get; set; }
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public bool NormalizeAudio { get; set; }
-        public bool NormalizeVideo { get; set; }
-        public bool NormalizeFramerate { get; set; }
-        public ResolutionViewModel Resolution { get; set; }
-        public int ThreadCount { get; set; }
-        public bool Transcode { get; set; }
-        public HardwareAccelerationKind HardwareAcceleration { get; set; }
-        public VaapiDriver VaapiDriver { get; set; }
-        public string VaapiDevice { get; set; }
-        public int VideoBitrate { get; set; }
-        public int VideoBufferSize { get; set; }
-        public string VideoCodec { get; set; }
-
-        public CreateFFmpegProfile ToCreate() =>
-            new(
-                Name,
-                ThreadCount,
-                Transcode,
-                HardwareAcceleration,
-                VaapiDriver,
-                VaapiDevice,
-                Resolution.Id,
-                NormalizeVideo,
-                VideoCodec,
-                VideoBitrate,
-                VideoBufferSize,
-                AudioCodec,
-                AudioBitrate,
-                AudioBufferSize,
-                NormalizeLoudness,
-                AudioChannels,
-                AudioSampleRate,
-                NormalizeAudio,
-                NormalizeFramerate
-            );
-
-        public UpdateFFmpegProfile ToUpdate() =>
-            new(
-                Id,
-                Name,
-                ThreadCount,
-                Transcode,
-                HardwareAcceleration,
-                VaapiDriver,
-                VaapiDevice,
-                Resolution.Id,
-                NormalizeVideo,
-                VideoCodec,
-                VideoBitrate,
-                VideoBufferSize,
-                AudioCodec,
-                AudioBitrate,
-                AudioBufferSize,
-                NormalizeLoudness,
-                AudioChannels,
-                AudioSampleRate,
-                NormalizeAudio,
-                NormalizeFramerate
-            );
     }
-}
+
+    public FFmpegProfileEditViewModel(FFmpegProfileViewModel viewModel)
+    {
+        AudioBitrate = viewModel.AudioBitrate;
+        AudioBufferSize = viewModel.AudioBufferSize;
+        AudioChannels = viewModel.AudioChannels;
+        AudioCodec = viewModel.AudioCodec;
+        AudioSampleRate = viewModel.AudioSampleRate;
+        NormalizeLoudness = viewModel.NormalizeLoudness;
+        Id = viewModel.Id;
+        Name = viewModel.Name;
+        NormalizeAudio = viewModel.NormalizeAudio;
+        NormalizeVideo = viewModel.NormalizeVideo;
+        NormalizeFramerate = viewModel.NormalizeFramerate;
+        Resolution = viewModel.Resolution;
+        ThreadCount = viewModel.ThreadCount;
+        Transcode = viewModel.Transcode;
+        HardwareAcceleration = viewModel.HardwareAcceleration;
+        VaapiDriver = viewModel.VaapiDriver;
+        VaapiDevice = viewModel.VaapiDevice;
+        VideoBitrate = viewModel.VideoBitrate;
+        VideoBufferSize = viewModel.VideoBufferSize;
+        VideoCodec = viewModel.VideoCodec;
+    }
+
+    public int AudioBitrate { get; set; }
+    public int AudioBufferSize { get; set; }
+    public int AudioChannels { get; set; }
+    public string AudioCodec { get; set; }
+    public int AudioSampleRate { get; set; }
+    public bool NormalizeLoudness { get; set; }
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public bool NormalizeAudio { get; set; }
+    public bool NormalizeVideo { get; set; }
+    public bool NormalizeFramerate { get; set; }
+    public ResolutionViewModel Resolution { get; set; }
+    public int ThreadCount { get; set; }
+    public bool Transcode { get; set; }
+    public HardwareAccelerationKind HardwareAcceleration { get; set; }
+    public VaapiDriver VaapiDriver { get; set; }
+    public string VaapiDevice { get; set; }
+    public int VideoBitrate { get; set; }
+    public int VideoBufferSize { get; set; }
+    public string VideoCodec { get; set; }
+
+    public CreateFFmpegProfile ToCreate() =>
+        new(
+            Name,
+            ThreadCount,
+            Transcode,
+            HardwareAcceleration,
+            VaapiDriver,
+            VaapiDevice,
+            Resolution.Id,
+            NormalizeVideo,
+            VideoCodec,
+            VideoBitrate,
+            VideoBufferSize,
+            AudioCodec,
+            AudioBitrate,
+            AudioBufferSize,
+            NormalizeLoudness,
+            AudioChannels,
+            AudioSampleRate,
+            NormalizeAudio,
+            NormalizeFramerate
+        );
+
+    public UpdateFFmpegProfile ToUpdate() =>
+        new(
+            Id,
+            Name,
+            ThreadCount,
+            Transcode,
+            HardwareAcceleration,
+            VaapiDriver,
+            VaapiDevice,
+            Resolution.Id,
+            NormalizeVideo,
+            VideoCodec,
+            VideoBitrate,
+            VideoBufferSize,
+            AudioCodec,
+            AudioBitrate,
+            AudioBufferSize,
+            NormalizeLoudness,
+            AudioChannels,
+            AudioSampleRate,
+            NormalizeAudio,
+            NormalizeFramerate
+        );
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/FillerPresetEditViewModel.cs b/ErsatzTV/ViewModels/FillerPresetEditViewModel.cs
index 5aaab4db0..a7796d960 100644
--- a/ErsatzTV/ViewModels/FillerPresetEditViewModel.cs
+++ b/ErsatzTV/ViewModels/FillerPresetEditViewModel.cs
@@ -1,112 +1,108 @@
-using System;
-using ErsatzTV.Application.Filler.Commands;
+using ErsatzTV.Application.Filler;
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Domain.Filler;
-using LanguageExt;
 using MediatR;
-using Unit = LanguageExt.Unit;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class FillerPresetEditViewModel
 {
-    public class FillerPresetEditViewModel
+    private FillerKind _fillerKind;
+    private TimeSpan? _duration;
+    private FillerMode _fillerMode;
+    private int? _count;
+    private ProgramScheduleItemCollectionType _collectionType;
+
+    public int Id { get; set; }
+    public string Name { get; set; }
+
+    public FillerKind FillerKind
     {
-        private FillerKind _fillerKind;
-        private TimeSpan? _duration;
-        private FillerMode _fillerMode;
-        private int? _count;
-        private ProgramScheduleItemCollectionType _collectionType;
-
-        public int Id { get; set; }
-        public string Name { get; set; }
-
-        public FillerKind FillerKind
+        get => _fillerKind;
+        set
         {
-            get => _fillerKind;
-            set
+            _fillerKind = value;
+            if (_fillerKind is FillerKind.Fallback or FillerKind.Tail)
             {
-                _fillerKind = value;
-                if (_fillerKind is FillerKind.Fallback or FillerKind.Tail)
-                {
-                    FillerMode = FillerMode.None;
-                }
+                FillerMode = FillerMode.None;
             }
         }
-
-        public FillerMode FillerMode
-        {
-            get => FillerKind is FillerKind.Fallback or FillerKind.Tail ? FillerMode.None : _fillerMode;
-            set => _fillerMode = value;
-        }
-
-        public TimeSpan? Duration
-        {
-            get => FillerMode == FillerMode.Duration ? _duration : null;
-            set => _duration = value;
-        }
-
-        public int? Count
-        {
-            get => FillerMode == FillerMode.Count ? _count : null;
-            set => _count = value;
-        }
-
-        public int? PadToNearestMinute { get; set; }
-
-        public ProgramScheduleItemCollectionType CollectionType
-        {
-            get => _collectionType;
-            set
-            {
-                if (_collectionType != value)
-                {
-                    Collection = null;
-                    MediaItem = null;
-                    MultiCollection = null;
-                    SmartCollection = null;
-                }
-
-                _collectionType = value;
-            }
-        }
-
-        public MediaCollectionViewModel Collection { get; set; }
-        public NamedMediaItemViewModel MediaItem { get; set; }
-        public MultiCollectionViewModel MultiCollection { get; set; }
-        public SmartCollectionViewModel SmartCollection { get; set; }
-
-        public IRequest<Either<BaseError, Unit>> ToEdit() =>
-            new UpdateFillerPreset(
-                Id,
-                Name,
-                FillerKind,
-                FillerMode,
-                Duration.Map(FixDuration),
-                Count,
-                PadToNearestMinute,
-                CollectionType,
-                Collection?.Id,
-                MediaItem?.MediaItemId,
-                MultiCollection?.Id,
-                SmartCollection?.Id);
-
-        public IRequest<Either<BaseError, Unit>> ToUpdate() =>
-            new CreateFillerPreset(
-                Name,
-                FillerKind,
-                FillerMode,
-                Duration.Map(FixDuration),
-                Count,
-                PadToNearestMinute,
-                CollectionType,
-                Collection?.Id,
-                MediaItem?.MediaItemId,
-                MultiCollection?.Id,
-                SmartCollection?.Id);
-        
-        private static TimeSpan FixDuration(TimeSpan duration) =>
-            duration > TimeSpan.FromDays(1) ? duration.Subtract(TimeSpan.FromDays(1)) : duration;
     }
-}
+
+    public FillerMode FillerMode
+    {
+        get => FillerKind is FillerKind.Fallback or FillerKind.Tail ? FillerMode.None : _fillerMode;
+        set => _fillerMode = value;
+    }
+
+    public TimeSpan? Duration
+    {
+        get => FillerMode == FillerMode.Duration ? _duration : null;
+        set => _duration = value;
+    }
+
+    public int? Count
+    {
+        get => FillerMode == FillerMode.Count ? _count : null;
+        set => _count = value;
+    }
+
+    public int? PadToNearestMinute { get; set; }
+
+    public ProgramScheduleItemCollectionType CollectionType
+    {
+        get => _collectionType;
+        set
+        {
+            if (_collectionType != value)
+            {
+                Collection = null;
+                MediaItem = null;
+                MultiCollection = null;
+                SmartCollection = null;
+            }
+
+            _collectionType = value;
+        }
+    }
+
+    public MediaCollectionViewModel Collection { get; set; }
+    public NamedMediaItemViewModel MediaItem { get; set; }
+    public MultiCollectionViewModel MultiCollection { get; set; }
+    public SmartCollectionViewModel SmartCollection { get; set; }
+
+    public IRequest<Either<BaseError, Unit>> ToEdit() =>
+        new UpdateFillerPreset(
+            Id,
+            Name,
+            FillerKind,
+            FillerMode,
+            Duration.Map(FixDuration),
+            Count,
+            PadToNearestMinute,
+            CollectionType,
+            Collection?.Id,
+            MediaItem?.MediaItemId,
+            MultiCollection?.Id,
+            SmartCollection?.Id);
+
+    public IRequest<Either<BaseError, Unit>> ToUpdate() =>
+        new CreateFillerPreset(
+            Name,
+            FillerKind,
+            FillerMode,
+            Duration.Map(FixDuration),
+            Count,
+            PadToNearestMinute,
+            CollectionType,
+            Collection?.Id,
+            MediaItem?.MediaItemId,
+            MultiCollection?.Id,
+            SmartCollection?.Id);
+        
+    private static TimeSpan FixDuration(TimeSpan duration) =>
+        duration > TimeSpan.FromDays(1) ? duration.Subtract(TimeSpan.FromDays(1)) : duration;
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/LocalLibraryEditViewModel.cs b/ErsatzTV/ViewModels/LocalLibraryEditViewModel.cs
index f7d63bd79..bb64628d0 100644
--- a/ErsatzTV/ViewModels/LocalLibraryEditViewModel.cs
+++ b/ErsatzTV/ViewModels/LocalLibraryEditViewModel.cs
@@ -1,15 +1,13 @@
-using System.Collections.Generic;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class LocalLibraryEditViewModel
 {
-    public class LocalLibraryEditViewModel
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public LibraryMediaKind MediaKind { get; set; }
-        public string NewPath { get; set; }
-        public List<LocalLibraryPathEditViewModel> Paths { get; set; }
-        public bool HasChanges { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public LibraryMediaKind MediaKind { get; set; }
+    public string NewPath { get; set; }
+    public List<LocalLibraryPathEditViewModel> Paths { get; set; }
+    public bool HasChanges { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/LocalLibraryPathEditViewModel.cs b/ErsatzTV/ViewModels/LocalLibraryPathEditViewModel.cs
index c06dd3aba..c9d418a0d 100644
--- a/ErsatzTV/ViewModels/LocalLibraryPathEditViewModel.cs
+++ b/ErsatzTV/ViewModels/LocalLibraryPathEditViewModel.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class LocalLibraryPathEditViewModel
 {
-    public class LocalLibraryPathEditViewModel
-    {
-        public int Id { get; set; }
-        public string Path { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Path { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/MultiCollectionEditViewModel.cs b/ErsatzTV/ViewModels/MultiCollectionEditViewModel.cs
index 8eca1d0d3..0032e1fe3 100644
--- a/ErsatzTV/ViewModels/MultiCollectionEditViewModel.cs
+++ b/ErsatzTV/ViewModels/MultiCollectionEditViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
+namespace ErsatzTV.ViewModels;
 
-namespace ErsatzTV.ViewModels
+public class MultiCollectionEditViewModel
 {
-    public class MultiCollectionEditViewModel
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public List<MultiCollectionItemEditViewModel> Items { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public List<MultiCollectionItemEditViewModel> Items { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/MultiCollectionItemEditViewModel.cs b/ErsatzTV/ViewModels/MultiCollectionItemEditViewModel.cs
index c6299dae6..97057698d 100644
--- a/ErsatzTV/ViewModels/MultiCollectionItemEditViewModel.cs
+++ b/ErsatzTV/ViewModels/MultiCollectionItemEditViewModel.cs
@@ -1,12 +1,11 @@
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class MultiCollectionItemEditViewModel
 {
-    public class MultiCollectionItemEditViewModel
-    {
-        public virtual MediaCollectionViewModel Collection { get; set; }
-        public bool ScheduleAsGroup { get; set; }
-        public PlaybackOrder PlaybackOrder { get; set; }
-    }
-}
+    public virtual MediaCollectionViewModel Collection { get; set; }
+    public bool ScheduleAsGroup { get; set; }
+    public PlaybackOrder PlaybackOrder { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/MultiCollectionSmartItemEditViewModel.cs b/ErsatzTV/ViewModels/MultiCollectionSmartItemEditViewModel.cs
index 52c9e5ed1..785310aa0 100644
--- a/ErsatzTV/ViewModels/MultiCollectionSmartItemEditViewModel.cs
+++ b/ErsatzTV/ViewModels/MultiCollectionSmartItemEditViewModel.cs
@@ -1,27 +1,26 @@
 using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class MultiCollectionSmartItemEditViewModel : MultiCollectionItemEditViewModel
 {
-    public class MultiCollectionSmartItemEditViewModel : MultiCollectionItemEditViewModel
+    private SmartCollectionViewModel _smartCollection;
+
+    public SmartCollectionViewModel SmartCollection
     {
-        private SmartCollectionViewModel _smartCollection;
-
-        public SmartCollectionViewModel SmartCollection
+        get => _smartCollection;
+        set
         {
-            get => _smartCollection;
-            set
-            {
-                _smartCollection = value;
+            _smartCollection = value;
 
-                Collection = new MediaCollectionViewModel(
-                    _smartCollection.Id,
-                    _smartCollection.Name,
-                    false,
-                    MediaItemState.Normal);
-            }
+            Collection = new MediaCollectionViewModel(
+                _smartCollection.Id,
+                _smartCollection.Name,
+                false,
+                MediaItemState.Normal);
         }
-
-        public override MediaCollectionViewModel Collection { get; set; }
     }
-}
+
+    public override MediaCollectionViewModel Collection { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/PlayoutEditViewModel.cs b/ErsatzTV/ViewModels/PlayoutEditViewModel.cs
index 33222c18e..515c33123 100644
--- a/ErsatzTV/ViewModels/PlayoutEditViewModel.cs
+++ b/ErsatzTV/ViewModels/PlayoutEditViewModel.cs
@@ -1,16 +1,15 @@
 using ErsatzTV.Application.Channels;
-using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Application.Playouts;
 using ErsatzTV.Application.ProgramSchedules;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.ViewModels
-{
-    public class PlayoutEditViewModel
-    {
-        public ChannelViewModel Channel { get; set; }
-        public ProgramScheduleViewModel ProgramSchedule { get; set; }
+namespace ErsatzTV.ViewModels;
 
-        public CreatePlayout ToCreate() =>
-            new(Channel.Id, ProgramSchedule.Id, ProgramSchedulePlayoutType.Flood);
-    }
-}
+public class PlayoutEditViewModel
+{
+    public ChannelViewModel Channel { get; set; }
+    public ProgramScheduleViewModel ProgramSchedule { get; set; }
+
+    public CreatePlayout ToCreate() =>
+        new(Channel.Id, ProgramSchedule.Id, ProgramSchedulePlayoutType.Flood);
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/PlexPathReplacementEditViewModel.cs b/ErsatzTV/ViewModels/PlexPathReplacementEditViewModel.cs
index 66214781b..60194a09c 100644
--- a/ErsatzTV/ViewModels/PlexPathReplacementEditViewModel.cs
+++ b/ErsatzTV/ViewModels/PlexPathReplacementEditViewModel.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class PlexPathReplacementEditViewModel
 {
-    public class PlexPathReplacementEditViewModel
-    {
-        public int Id { get; set; }
-        public string PlexPath { get; set; }
-        public string LocalPath { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string PlexPath { get; set; }
+    public string LocalPath { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/ProgramScheduleEditViewModel.cs b/ErsatzTV/ViewModels/ProgramScheduleEditViewModel.cs
index 5b2037a51..9b1a9f74d 100644
--- a/ErsatzTV/ViewModels/ProgramScheduleEditViewModel.cs
+++ b/ErsatzTV/ViewModels/ProgramScheduleEditViewModel.cs
@@ -1,20 +1,18 @@
-using ErsatzTV.Application.ProgramSchedules.Commands;
-using ErsatzTV.Core.Domain;
+using ErsatzTV.Application.ProgramSchedules;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class ProgramScheduleEditViewModel
 {
-    public class ProgramScheduleEditViewModel
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public bool KeepMultiPartEpisodesTogether { get; set; }
-        public bool TreatCollectionsAsShows { get; set; }
-        public bool ShuffleScheduleItems { get; set; }
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public bool KeepMultiPartEpisodesTogether { get; set; }
+    public bool TreatCollectionsAsShows { get; set; }
+    public bool ShuffleScheduleItems { get; set; }
 
-        public UpdateProgramSchedule ToUpdate() =>
-            new(Id, Name, KeepMultiPartEpisodesTogether, TreatCollectionsAsShows, ShuffleScheduleItems);
+    public UpdateProgramSchedule ToUpdate() =>
+        new(Id, Name, KeepMultiPartEpisodesTogether, TreatCollectionsAsShows, ShuffleScheduleItems);
 
-        public CreateProgramSchedule ToCreate() =>
-            new(Name, KeepMultiPartEpisodesTogether, TreatCollectionsAsShows, ShuffleScheduleItems);
-    }
-}
+    public CreateProgramSchedule ToCreate() =>
+        new(Name, KeepMultiPartEpisodesTogether, TreatCollectionsAsShows, ShuffleScheduleItems);
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/ProgramScheduleItemEditViewModel.cs b/ErsatzTV/ViewModels/ProgramScheduleItemEditViewModel.cs
index 649b829e0..ba54dee4c 100644
--- a/ErsatzTV/ViewModels/ProgramScheduleItemEditViewModel.cs
+++ b/ErsatzTV/ViewModels/ProgramScheduleItemEditViewModel.cs
@@ -1,5 +1,4 @@
-using System;
-using System.ComponentModel;
+using System.ComponentModel;
 using System.Runtime.CompilerServices;
 using ErsatzTV.Annotations;
 using ErsatzTV.Application.Filler;
@@ -7,101 +6,100 @@ using ErsatzTV.Application.MediaCollections;
 using ErsatzTV.Application.MediaItems;
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class ProgramScheduleItemEditViewModel : INotifyPropertyChanged
 {
-    public class ProgramScheduleItemEditViewModel : INotifyPropertyChanged
+    private ProgramScheduleItemCollectionType _collectionType;
+    private int? _multipleCount;
+    private TimeSpan? _playoutDuration;
+    private TimeSpan? _startTime;
+
+    public int Id { get; set; }
+    public int Index { get; set; }
+    public StartType StartType { get; set; }
+
+    public TimeSpan? StartTime
     {
-        private ProgramScheduleItemCollectionType _collectionType;
-        private int? _multipleCount;
-        private TimeSpan? _playoutDuration;
-        private TimeSpan? _startTime;
+        get => StartType == StartType.Fixed ? _startTime : null;
+        set => _startTime = value;
+    }
 
-        public int Id { get; set; }
-        public int Index { get; set; }
-        public StartType StartType { get; set; }
+    public PlayoutMode PlayoutMode { get; set; }
 
-        public TimeSpan? StartTime
+    public ProgramScheduleItemCollectionType CollectionType
+    {
+        get => _collectionType;
+        set
         {
-            get => StartType == StartType.Fixed ? _startTime : null;
-            set => _startTime = value;
-        }
-
-        public PlayoutMode PlayoutMode { get; set; }
-
-        public ProgramScheduleItemCollectionType CollectionType
-        {
-            get => _collectionType;
-            set
+            if (_collectionType != value)
             {
-                if (_collectionType != value)
-                {
-                    _collectionType = value;
+                _collectionType = value;
 
-                    Collection = null;
-                    MultiCollection = null;
-                    MediaItem = null;
-                    SmartCollection = null;
+                Collection = null;
+                MultiCollection = null;
+                MediaItem = null;
+                SmartCollection = null;
 
-                    OnPropertyChanged(nameof(Collection));
-                    OnPropertyChanged(nameof(MultiCollection));
-                    OnPropertyChanged(nameof(MediaItem));
-                    OnPropertyChanged(nameof(SmartCollection));
-                }
+                OnPropertyChanged(nameof(Collection));
+                OnPropertyChanged(nameof(MultiCollection));
+                OnPropertyChanged(nameof(MediaItem));
+                OnPropertyChanged(nameof(SmartCollection));
+            }
 
-                if (_collectionType == ProgramScheduleItemCollectionType.MultiCollection)
-                {
-                    PlaybackOrder = PlaybackOrder.Shuffle;
-                }
+            if (_collectionType == ProgramScheduleItemCollectionType.MultiCollection)
+            {
+                PlaybackOrder = PlaybackOrder.Shuffle;
             }
         }
-
-        public MediaCollectionViewModel Collection { get; set; }
-        public MultiCollectionViewModel MultiCollection { get; set; }
-        public SmartCollectionViewModel SmartCollection { get; set; }
-        public NamedMediaItemViewModel MediaItem { get; set; }
-        public FillerPresetViewModel PreRollFiller { get; set; }
-        public FillerPresetViewModel MidRollFiller { get; set; }
-        public FillerPresetViewModel PostRollFiller { get; set; }
-        public FillerPresetViewModel TailFiller { get; set; }
-        public FillerPresetViewModel FallbackFiller { get; set; }
-
-        public string CollectionName => CollectionType switch
-        {
-            ProgramScheduleItemCollectionType.Collection => Collection?.Name,
-            ProgramScheduleItemCollectionType.TelevisionShow => MediaItem?.Name,
-            ProgramScheduleItemCollectionType.TelevisionSeason => MediaItem?.Name,
-            ProgramScheduleItemCollectionType.Artist => MediaItem?.Name,
-            ProgramScheduleItemCollectionType.MultiCollection => MultiCollection?.Name,
-            ProgramScheduleItemCollectionType.SmartCollection => SmartCollection?.Name,
-            _ => string.Empty
-        };
-
-        public PlaybackOrder PlaybackOrder { get; set; }
-
-        public int? MultipleCount
-        {
-            get => PlayoutMode == PlayoutMode.Multiple ? _multipleCount : null;
-            set => _multipleCount = value;
-        }
-
-        public TimeSpan? PlayoutDuration
-        {
-            get => PlayoutMode == PlayoutMode.Duration ? _playoutDuration : null;
-            set => _playoutDuration = value;
-        }
-
-        public TailMode TailMode { get; set; }
-        
-        public string CustomTitle { get; set; }
-
-        public GuideMode GuideMode { get; set; }
-
-        public event PropertyChangedEventHandler PropertyChanged;
-
-        [NotifyPropertyChangedInvocator]
-        protected virtual void OnPropertyChanged(
-            [CallerMemberName]
-            string propertyName = null) =>
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
-}
+
+    public MediaCollectionViewModel Collection { get; set; }
+    public MultiCollectionViewModel MultiCollection { get; set; }
+    public SmartCollectionViewModel SmartCollection { get; set; }
+    public NamedMediaItemViewModel MediaItem { get; set; }
+    public FillerPresetViewModel PreRollFiller { get; set; }
+    public FillerPresetViewModel MidRollFiller { get; set; }
+    public FillerPresetViewModel PostRollFiller { get; set; }
+    public FillerPresetViewModel TailFiller { get; set; }
+    public FillerPresetViewModel FallbackFiller { get; set; }
+
+    public string CollectionName => CollectionType switch
+    {
+        ProgramScheduleItemCollectionType.Collection => Collection?.Name,
+        ProgramScheduleItemCollectionType.TelevisionShow => MediaItem?.Name,
+        ProgramScheduleItemCollectionType.TelevisionSeason => MediaItem?.Name,
+        ProgramScheduleItemCollectionType.Artist => MediaItem?.Name,
+        ProgramScheduleItemCollectionType.MultiCollection => MultiCollection?.Name,
+        ProgramScheduleItemCollectionType.SmartCollection => SmartCollection?.Name,
+        _ => string.Empty
+    };
+
+    public PlaybackOrder PlaybackOrder { get; set; }
+
+    public int? MultipleCount
+    {
+        get => PlayoutMode == PlayoutMode.Multiple ? _multipleCount : null;
+        set => _multipleCount = value;
+    }
+
+    public TimeSpan? PlayoutDuration
+    {
+        get => PlayoutMode == PlayoutMode.Duration ? _playoutDuration : null;
+        set => _playoutDuration = value;
+    }
+
+    public TailMode TailMode { get; set; }
+        
+    public string CustomTitle { get; set; }
+
+    public GuideMode GuideMode { get; set; }
+
+    public event PropertyChangedEventHandler PropertyChanged;
+
+    [NotifyPropertyChangedInvocator]
+    protected virtual void OnPropertyChanged(
+        [CallerMemberName]
+        string propertyName = null) =>
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/ProgramScheduleItemsEditViewModel.cs b/ErsatzTV/ViewModels/ProgramScheduleItemsEditViewModel.cs
index f89f610fe..647a9e0c7 100644
--- a/ErsatzTV/ViewModels/ProgramScheduleItemsEditViewModel.cs
+++ b/ErsatzTV/ViewModels/ProgramScheduleItemsEditViewModel.cs
@@ -1,11 +1,8 @@
-using System.Collections.Generic;
+namespace ErsatzTV.ViewModels;
 
-namespace ErsatzTV.ViewModels
+public class ProgramScheduleItemsEditViewModel
 {
-    public class ProgramScheduleItemsEditViewModel
-    {
-        public string Name { get; set; }
-        public bool ShuffleScheduleItems { get; set; }
-        public List<ProgramScheduleItemEditViewModel> Items { get; set; }
-    }
-}
+    public string Name { get; set; }
+    public bool ShuffleScheduleItems { get; set; }
+    public List<ProgramScheduleItemEditViewModel> Items { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/RemoteMediaSourceEditViewModel.cs b/ErsatzTV/ViewModels/RemoteMediaSourceEditViewModel.cs
index 81f7430bc..8b8841abd 100644
--- a/ErsatzTV/ViewModels/RemoteMediaSourceEditViewModel.cs
+++ b/ErsatzTV/ViewModels/RemoteMediaSourceEditViewModel.cs
@@ -1,8 +1,7 @@
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class RemoteMediaSourceEditViewModel
 {
-    public class RemoteMediaSourceEditViewModel
-    {
-        public string Address { get; set; }
-        public string ApiKey { get; set; }
-    }
-}
+    public string Address { get; set; }
+    public string ApiKey { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/RemoteMediaSourceLibraryEditViewModel.cs b/ErsatzTV/ViewModels/RemoteMediaSourceLibraryEditViewModel.cs
index 0387390f6..c75245042 100644
--- a/ErsatzTV/ViewModels/RemoteMediaSourceLibraryEditViewModel.cs
+++ b/ErsatzTV/ViewModels/RemoteMediaSourceLibraryEditViewModel.cs
@@ -1,12 +1,11 @@
 using ErsatzTV.Core.Domain;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class RemoteMediaSourceLibraryEditViewModel
 {
-    public class RemoteMediaSourceLibraryEditViewModel
-    {
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public LibraryMediaKind MediaKind { get; init; }
-        public bool ShouldSyncItems { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public LibraryMediaKind MediaKind { get; init; }
+    public bool ShouldSyncItems { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/RemoteMediaSourcePathReplacementEditViewModel.cs b/ErsatzTV/ViewModels/RemoteMediaSourcePathReplacementEditViewModel.cs
index 170840ff7..48bb00c37 100644
--- a/ErsatzTV/ViewModels/RemoteMediaSourcePathReplacementEditViewModel.cs
+++ b/ErsatzTV/ViewModels/RemoteMediaSourcePathReplacementEditViewModel.cs
@@ -1,9 +1,8 @@
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class RemoteMediaSourcePathReplacementEditViewModel
 {
-    public class RemoteMediaSourcePathReplacementEditViewModel
-    {
-        public int Id { get; set; }
-        public string RemotePath { get; set; }
-        public string LocalPath { get; set; }
-    }
-}
+    public int Id { get; set; }
+    public string RemotePath { get; set; }
+    public string LocalPath { get; set; }
+}
\ No newline at end of file
diff --git a/ErsatzTV/ViewModels/WatermarkEditViewModel.cs b/ErsatzTV/ViewModels/WatermarkEditViewModel.cs
index 470f83865..eba56c9a2 100644
--- a/ErsatzTV/ViewModels/WatermarkEditViewModel.cs
+++ b/ErsatzTV/ViewModels/WatermarkEditViewModel.cs
@@ -1,78 +1,76 @@
 using ErsatzTV.Application.Watermarks;
-using ErsatzTV.Application.Watermarks.Commands;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.FFmpeg.State;
 
-namespace ErsatzTV.ViewModels
+namespace ErsatzTV.ViewModels;
+
+public class WatermarkEditViewModel
 {
-    public class WatermarkEditViewModel
+    public WatermarkEditViewModel()
     {
-        public WatermarkEditViewModel()
-        {
-        }
-
-        public WatermarkEditViewModel(WatermarkViewModel vm)
-        {
-            Id = vm.Id;
-            Name = vm.Name;
-            Image = vm.Image;
-            Mode = vm.Mode;
-            ImageSource = vm.ImageSource;
-            Location = vm.Location;
-            Size = vm.Size;
-            Width = vm.Width;
-            HorizontalMargin = vm.HorizontalMargin;
-            VerticalMargin = vm.VerticalMargin;
-            FrequencyMinutes = vm.FrequencyMinutes;
-            DurationSeconds = vm.DurationSeconds;
-            Opacity = vm.Opacity;
-        }
-
-        public int Id { get; set; }
-        public string Name { get; set; }
-        public string Image { get; set; }
-        public ChannelWatermarkMode Mode { get; set; }
-        public ChannelWatermarkImageSource ImageSource { get; set; }
-        public WatermarkLocation Location { get; set; }
-        public WatermarkSize Size { get; set; }
-        public int Width { get; set; }
-        public int HorizontalMargin { get; set; }
-        public int VerticalMargin { get; set; }
-        public int FrequencyMinutes { get; set; }
-        public int DurationSeconds { get; set; }
-        public int Opacity { get; set; }
-
-        public CreateWatermark ToCreate() =>
-            new(
-                Name,
-                Image,
-                Mode,
-                ImageSource,
-                Location,
-                Size,
-                Width,
-                HorizontalMargin,
-                VerticalMargin,
-                FrequencyMinutes,
-                DurationSeconds,
-                Opacity
-            );
-
-        public UpdateWatermark ToUpdate() =>
-            new(
-                Id,
-                Name,
-                Image,
-                Mode,
-                ImageSource,
-                Location,
-                Size,
-                Width,
-                HorizontalMargin,
-                VerticalMargin,
-                FrequencyMinutes,
-                DurationSeconds,
-                Opacity
-            );
     }
-}
+
+    public WatermarkEditViewModel(WatermarkViewModel vm)
+    {
+        Id = vm.Id;
+        Name = vm.Name;
+        Image = vm.Image;
+        Mode = vm.Mode;
+        ImageSource = vm.ImageSource;
+        Location = vm.Location;
+        Size = vm.Size;
+        Width = vm.Width;
+        HorizontalMargin = vm.HorizontalMargin;
+        VerticalMargin = vm.VerticalMargin;
+        FrequencyMinutes = vm.FrequencyMinutes;
+        DurationSeconds = vm.DurationSeconds;
+        Opacity = vm.Opacity;
+    }
+
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public string Image { get; set; }
+    public ChannelWatermarkMode Mode { get; set; }
+    public ChannelWatermarkImageSource ImageSource { get; set; }
+    public WatermarkLocation Location { get; set; }
+    public WatermarkSize Size { get; set; }
+    public int Width { get; set; }
+    public int HorizontalMargin { get; set; }
+    public int VerticalMargin { get; set; }
+    public int FrequencyMinutes { get; set; }
+    public int DurationSeconds { get; set; }
+    public int Opacity { get; set; }
+
+    public CreateWatermark ToCreate() =>
+        new(
+            Name,
+            Image,
+            Mode,
+            ImageSource,
+            Location,
+            Size,
+            Width,
+            HorizontalMargin,
+            VerticalMargin,
+            FrequencyMinutes,
+            DurationSeconds,
+            Opacity
+        );
+
+    public UpdateWatermark ToUpdate() =>
+        new(
+            Id,
+            Name,
+            Image,
+            Mode,
+            ImageSource,
+            Location,
+            Size,
+            Width,
+            HorizontalMargin,
+            VerticalMargin,
+            FrequencyMinutes,
+            DurationSeconds,
+            Opacity
+        );
+}
\ No newline at end of file
diff --git a/ErsatzTV/_Imports.razor b/ErsatzTV/_Imports.razor
index f6dc56d31..d3322a723 100644
--- a/ErsatzTV/_Imports.razor
+++ b/ErsatzTV/_Imports.razor
@@ -1,6 +1,7 @@
 @using System.IO
 @using System.Net.Http
 @using System.Net.Http.Json
+@using System.Threading
 @using System.Threading.Channels
 @using Microsoft.AspNetCore.Authorization
 @using Microsoft.AspNetCore.Components.Authorization
@@ -23,4 +24,5 @@
 @using ErsatzTV.Core.Interfaces.Locking
 @using ErsatzTV.Infrastructure.Data
 @using ErsatzTV.Shared
-@using ErsatzTV.ViewModels
\ No newline at end of file
+@using ErsatzTV.ViewModels
+@using Unit = LanguageExt.Unit;
\ No newline at end of file