update changelog for release 55 [no ci]

* add "shuffle in order" option for multi-collections

* use balanced shuffle instead of random

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '30 3 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'csharp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

CHANGELOG.md

@@ -5,6 +5,36 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [0.0.55-alpha] - 2021-09-03
+### Fixed
+- Fix all local library scanners to ignore dot underscore files (`._`)
+
+## [0.0.54-alpha] - 2021-08-21
+### Added
+- Add `Shuffle In Order` playback order for multi-collections.
+  - This is useful for randomizing multiple collections/shows on a single channel, while each collection maintains proper ordering (custom or chronological)
+
+### Fixed
+- Fix bug parsing ffprobe output in cultures where `.` is a group/thousands separator
+  - This bug likely prevented ETV from scheduling correctly or working at all in those cultures
+  - After installing a version with this fix, affected content will need to be removed from ETV and re-added
+
+## [0.0.53-alpha] - 2021-08-01
+### Fixed
+- Fix error message displayed after building empty playout
+- Fix Emby and Jellyfin links
+
+### Changed
+- Always proxy Jellyfin and Emby artwork; this fixes artwork in some networking scenarios
+
+## [0.0.52-alpha] - 2021-07-22
+### Added
+- Add multiple local libraries to better organize your media
+- Add `Move Library Path` function to support reorganizing existing local libraries
+
+### Fixed
+- Fix bug preventing playouts from rebuilding after an empty collection is encountered within a multi-collection
+
 ## [0.0.51-alpha] - 2021-07-18
 ### Added
 - Add `Multi Collection` to support shuffling multiple collections within a single schedule item
@@ -520,7 +550,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Initial release to facilitate testing outside of Docker.
 
 
-[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.51-alpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.55-alpha...HEAD
+[0.0.55-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.54-alpha...v0.0.55-alpha
+[0.0.54-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.53-alpha...v0.0.54-alpha
+[0.0.53-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.52-alpha...v0.0.53-alpha
+[0.0.52-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.51-alpha...v0.0.52-alpha
 [0.0.51-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.50-alpha...v0.0.51-alpha
 [0.0.50-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.49-prealpha...v0.0.50-alpha
 [0.0.49-prealpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.48-prealpha...v0.0.49-prealpha

ErsatzTV.Application/Libraries/Commands/CreateLocalLibrary.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+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>>;
+}

ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs

@@ -0,0 +1,84 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaSources.Commands;
+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
+{
+    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)
+        {
+            _workerChannel = workerChannel;
+            _entityLocker = entityLocker;
+            _dbContextFactory = dbContextFactory;
+        }
+
+        public async Task<Either<BaseError, LocalLibraryViewModel>> Handle(
+            CreateLocalLibrary request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            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."));
+    }
+}

ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs

@@ -19,8 +19,8 @@ namespace ErsatzTV.Application.Libraries.Commands
     {
         private readonly ILibraryRepository _libraryRepository;
 
-        public CreateLocalLibraryPathHandler(ILibraryRepository mediaSourceRepository) =>
-            _libraryRepository = mediaSourceRepository;
+        public CreateLocalLibraryPathHandler(ILibraryRepository libraryRepository) =>
+            _libraryRepository = libraryRepository;
 
         public Task<Either<BaseError, LocalLibraryPathViewModel>> Handle(
             CreateLocalLibraryPath request,
@@ -45,7 +45,6 @@ namespace ErsatzTV.Application.Libraries.Commands
             List<string> allPaths = await _libraryRepository.GetLocalPaths(request.LibraryId)
                 .Map(list => list.Map(c => c.Path).ToList());
 
-
             return Optional(request.Path)
                 .Filter(folder => allPaths.ForAll(f => !AreSubPaths(f, folder)))
                 .ToValidation<BaseError>("Path must not belong to another library path");

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibrary.cs

@@ -0,0 +1,9 @@
+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>>;
+}

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryHandler.cs

@@ -0,0 +1,70 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+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
+{
+    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)
+        {
+            _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 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
+                      INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
+                      WHERE LP.LibraryId = @LibraryId",
+                    new { LibraryId = localLibrary.Id })
+                .Map(result => result.ToList());
+
+            await _searchIndex.RemoveItems(ids);
+            _searchIndex.Commit();
+
+            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."));
+    }
+}

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPath.cs

@@ -1,7 +0,0 @@
-using ErsatzTV.Core;
-using LanguageExt;
-
-namespace ErsatzTV.Application.Libraries.Commands
-{
-    public record DeleteLocalLibraryPath(int LocalLibraryPathId) : MediatR.IRequest<Either<BaseError, Unit>>;
-}

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryPathHandler.cs

@@ -1,46 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using ErsatzTV.Core;
-using ErsatzTV.Core.Domain;
-using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.Core.Interfaces.Search;
-using LanguageExt;
-
-namespace ErsatzTV.Application.Libraries.Commands
-{
-    public class
-        DeleteLocalLibraryPathHandler : MediatR.IRequestHandler<DeleteLocalLibraryPath, Either<BaseError, Unit>>
-    {
-        private readonly ILibraryRepository _libraryRepository;
-        private readonly ISearchIndex _searchIndex;
-
-        public DeleteLocalLibraryPathHandler(ILibraryRepository libraryRepository, ISearchIndex searchIndex)
-        {
-            _libraryRepository = libraryRepository;
-            _searchIndex = searchIndex;
-        }
-
-        public Task<Either<BaseError, Unit>> Handle(
-            DeleteLocalLibraryPath request,
-            CancellationToken cancellationToken) =>
-            MediaSourceMustExist(request)
-                .MapT(DoDeletion)
-                .Bind(t => t.ToEitherAsync());
-
-        private async Task<Unit> DoDeletion(LibraryPath libraryPath)
-        {
-            List<int> ids = await _libraryRepository.GetMediaIdsByLocalPath(libraryPath.Id);
-            await _searchIndex.RemoveItems(ids);
-            _searchIndex.Commit();
-            await _libraryRepository.DeleteLocalPath(libraryPath.Id);
-            return Unit.Default;
-        }
-
-        private async Task<Validation<BaseError, LibraryPath>> MediaSourceMustExist(DeleteLocalLibraryPath request) =>
-            (await _libraryRepository.GetPath(request.LocalLibraryPathId))
-            .HeadOrNone()
-            .ToValidation<BaseError>(
-                $"Local library path {request.LocalLibraryPathId} does not exist.");
-    }
-}

ErsatzTV.Application/Libraries/Commands/ILocalLibraryRequest.cs

@@ -0,0 +1,7 @@
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public interface ILocalLibraryRequest
+    {
+        public string Name { get; }
+    }
+}

ErsatzTV.Application/Libraries/Commands/LocalLibraryHandlerBase.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+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
+{
+    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)
+        {
+            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))))
+                .Filter(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);
+        }
+    }
+}

ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPath.cs

@@ -0,0 +1,9 @@
+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>>;
+}

ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPathHandler.cs

@@ -0,0 +1,121 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+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
+{
+    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)
+        {
+            _searchIndex = searchIndex;
+            _searchRepository = searchRepository;
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+            _logger = 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 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)
+            {
+                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)
+                    {
+                        _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));
+
+        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 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
+                      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
+                      INNER JOIN MediaVersion MV on MediaFile.MediaVersionId = MV.Id
+                      WHERE MV.MusicVideoId = @Id", new { mediaItem.Id }),
+                _ => null
+            };
+
+        private record Parameters(LibraryPath LibraryPath, LocalLibrary Library);
+    }
+}

ErsatzTV.Application/Libraries/Commands/UpdateLocalLibrary.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Commands
+{
+    public record UpdateLocalLibraryPath(int Id, string Path);
+
+    public record UpdateLocalLibrary(int Id, string Name, List<UpdateLocalLibraryPath> Paths) : ILocalLibraryRequest,
+        IRequest<Either<BaseError, LocalLibraryViewModel>>;
+}

ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs

@@ -0,0 +1,110 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.MediaSources.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Locking;
+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
+{
+    public class UpdateLocalLibraryHandler : LocalLibraryHandlerBase,
+        IRequestHandler<UpdateLocalLibrary, Either<BaseError, LocalLibraryViewModel>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
+        private readonly IEntityLocker _entityLocker;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public UpdateLocalLibraryHandler(
+            ChannelWriter<IBackgroundServiceRequest> workerChannel,
+            IEntityLocker entityLocker,
+            IDbContextFactory<TvContext> dbContextFactory)
+        {
+            _workerChannel = workerChannel;
+            _entityLocker = entityLocker;
+            _dbContextFactory = dbContextFactory;
+        }
+
+        public async Task<Either<BaseError, LocalLibraryViewModel>> Handle(
+            UpdateLocalLibrary request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            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;
+            
+            // toAdd
+            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();
+
+            existing.Paths.RemoveAll(toRemove.Contains);
+            existing.Paths.AddRange(toAdd);
+
+            await dbContext.SaveChangesAsync();
+
+            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();
+        }
+    }
+}

ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibrary.cs

@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public record CountMediaItemsByLibrary(int LibraryId) : IRequest<int>;
+}

ErsatzTV.Application/Libraries/Queries/CountMediaItemsByLibraryHandler.cs

@@ -0,0 +1,25 @@
+using System.Data;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public class CountMediaItemsByLibraryHandler : IRequestHandler<CountMediaItemsByLibrary, int>
+    {
+        private readonly IDbConnection _dbConnection;
+
+        public CountMediaItemsByLibraryHandler(IDbConnection dbConnection)
+        {
+            _dbConnection = dbConnection;
+        }
+
+        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 });
+    }
+}

ErsatzTV.Application/Libraries/Queries/GetAllLocalLibraries.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public record GetAllLocalLibraries : IRequest<List<LocalLibraryViewModel>>;
+}

ErsatzTV.Application/Libraries/Queries/GetAllLocalLibrariesHandler.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using LanguageExt;
+using MediatR;
+using static ErsatzTV.Application.Libraries.Mapper;
+
+namespace ErsatzTV.Application.Libraries.Queries
+{
+    public class GetAllLocalLibrariesHandler : IRequestHandler<GetAllLocalLibraries, List<LocalLibraryViewModel>>
+    {
+        private readonly ILibraryRepository _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());
+    }
+}

ErsatzTV.Application/MediaCards/Mapper.cs

@@ -123,12 +123,12 @@ namespace ErsatzTV.Application.MediaCards
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                artwork = JellyfinUrl.ForArtwork(maybeJellyfin, artwork)
+                artwork = JellyfinUrl.RelativeProxyForArtwork(artwork)
                     .SetQueryParam("fillHeight", 440);
             }
             else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
             {
-                artwork = EmbyUrl.ForArtwork(maybeEmby, artwork)
+                artwork = EmbyUrl.RelativeProxyForArtwork(artwork)
                     .SetQueryParam("maxHeight", 440);
             }
 
@@ -171,12 +171,12 @@ namespace ErsatzTV.Application.MediaCards
 
             if (maybeJellyfin.IsSome && poster.StartsWith("jellyfin://"))
             {
-                poster = JellyfinUrl.ForArtwork(maybeJellyfin, poster)
+                poster = JellyfinUrl.RelativeProxyForArtwork(poster)
                     .SetQueryParam("fillHeight", 440);
             }
             else if (maybeEmby.IsSome && poster.StartsWith("emby://"))
             {
-                poster = EmbyUrl.ForArtwork(maybeEmby, poster)
+                poster = EmbyUrl.RelativeProxyForArtwork(poster)
                     .SetQueryParam("maxHeight", 440);
             }
 
@@ -193,12 +193,12 @@ namespace ErsatzTV.Application.MediaCards
 
             if (maybeJellyfin.IsSome && thumb.StartsWith("jellyfin://"))
             {
-                thumb = JellyfinUrl.ForArtwork(maybeJellyfin, thumb)
+                thumb = JellyfinUrl.RelativeProxyForArtwork(thumb)
                     .SetQueryParam("fillHeight", 220);
             }
             else if (maybeEmby.IsSome && thumb.StartsWith("emby://"))
             {
-                thumb = EmbyUrl.ForArtwork(maybeEmby, thumb)
+                thumb = EmbyUrl.RelativeProxyForArtwork(thumb)
                     .SetQueryParam("maxHeight", 220);
             }
 

ErsatzTV.Application/MediaCollections/Commands/AddArtistToCollectionHandler.cs

@@ -73,7 +73,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
             AddArtistToCollection request) =>
             dbContext.Artists
                 .SelectOneAsync(a => a.Id, a => a.Id == request.ArtistId)
-                .Map(o => o.ToValidation<BaseError>("Music video does not exist"));
+                .Map(o => o.ToValidation<BaseError>("Artist does not exist"));
 
         private record Parameters(Collection Collection, Artist Artist);
     }

ErsatzTV.Application/Movies/Mapper.cs

@@ -66,7 +66,7 @@ namespace ErsatzTV.Application.Movies
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                Url url = JellyfinUrl.ForArtwork(maybeJellyfin, artwork);
+                Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
                 if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
                 {
                     url.SetQueryParam("fillHeight", 440);
@@ -76,7 +76,7 @@ namespace ErsatzTV.Application.Movies
             }
             else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
             {
-                Url url = EmbyUrl.ForArtwork(maybeEmby, artwork);
+                Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
                 if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail)
                 {
                     url.SetQueryParam("maxHeight", 440);

ErsatzTV.Application/ProgramSchedules/Commands/ProgramScheduleItemCommandBase.cs

@@ -24,6 +24,23 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             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;
+                }
+            }
+            else if (item.PlaybackOrder == PlaybackOrder.ShuffleInOrder)
+            {
+                return BaseError.New("Invalid playback order: 'Shuffle In Order'");
+            }
+
             switch (item.PlayoutMode)
             {
                 case PlayoutMode.Flood:

ErsatzTV.Application/ProgramSchedules/Commands/ReplaceProgramScheduleItemsHandler.cs

@@ -112,7 +112,5 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
             int? CollectionId,
             int? MediaItemId,
             int? MultiCollectionId);
-
-        private record CollectionKeyOrder(CollectionKey Key, PlaybackOrder PlaybackOrder);
     }
 }

ErsatzTV.Application/Television/Mapper.cs

@@ -80,7 +80,7 @@ namespace ErsatzTV.Application.Television
 
             if (maybeJellyfin.IsSome && artwork.StartsWith("jellyfin://"))
             {
-                Url url = JellyfinUrl.ForArtwork(maybeJellyfin, artwork);
+                Url url = JellyfinUrl.RelativeProxyForArtwork(artwork);
                 if (artworkKind == ArtworkKind.Poster)
                 {
                     url.SetQueryParam("fillHeight", 440);
@@ -90,7 +90,7 @@ namespace ErsatzTV.Application.Television
             }
             else if (maybeEmby.IsSome && artwork.StartsWith("emby://"))
             {
-                Url url = EmbyUrl.ForArtwork(maybeEmby, artwork);
+                Url url = EmbyUrl.RelativeProxyForArtwork(artwork);
                 if (artworkKind == ArtworkKind.Poster)
                 {
                     url.SetQueryParam("maxHeight", 440);

ErsatzTV.Core.Tests/ErsatzTV.Core.Tests.csproj

@@ -10,10 +10,10 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="FluentAssertions" Version="5.10.3" />
+      <PackageReference Include="FluentAssertions" Version="6.1.0" />
       <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
       <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
-      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
       <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.10.56">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

ErsatzTV.Core.Tests/Metadata/FallbackMetadataProviderTests.cs

@@ -91,7 +91,7 @@ namespace ErsatzTV.Core.Tests.Metadata
                 });
 
             metadata.Count.Should().Be(2);
-            metadata.Map(m => m.EpisodeNumber).Should().BeEquivalentTo(episode1, episode2);
+            metadata.Map(m => m.EpisodeNumber).Should().BeEquivalentTo(new[] { episode1, episode2 });
         }
 
         [Test]

ErsatzTV.Core.Tests/Metadata/LocalStatisticsProviderTests.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Metadata;
+using FluentAssertions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+
+namespace ErsatzTV.Core.Tests.Metadata
+{
+    [TestFixture]
+    public class LocalStatisticsProviderTests
+    {
+        [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 input = new LocalStatisticsProvider.FFprobe(
+                new LocalStatisticsProvider.FFprobeFormat("123.45"),
+                new List<LocalStatisticsProvider.FFprobeStream>());
+
+            MediaVersion result = provider.ProjectToMediaVersion("test", input);
+
+            result.Duration.Should().Be(TimeSpan.FromSeconds(123.45));
+        }
+    }
+}

ErsatzTV.Core.Tests/Metadata/MovieFolderScannerTests.cs

@@ -405,6 +405,48 @@ namespace ErsatzTV.Core.Tests.Metadata
                         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(

ErsatzTV.Core.Tests/Scheduling/ShuffledContentTests.cs

@@ -84,7 +84,7 @@ namespace ErsatzTV.Core.Tests.Scheduling
             }
 
             list.Should().NotEqual(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
-            list.Should().BeEquivalentTo(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]

ErsatzTV.Core/Domain/PlaybackOrder.cs

@@ -4,6 +4,7 @@
     {
         Chronological = 1,
         Random = 2,
-        Shuffle = 3
+        Shuffle = 3,
+        ShuffleInOrder = 4
     }
 }

ErsatzTV.Core/Emby/EmbyUrl.cs

@@ -63,5 +63,21 @@ namespace ErsatzTV.Core.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);
+        }
     }
 }

ErsatzTV.Core/ErsatzTV.Core.csproj

@@ -24,5 +24,11 @@
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.Sinks.Console" Version="4.0.0" />
     </ItemGroup>
+    
+    <ItemGroup>
+        <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+            <_Parameter1>ErsatzTV.Core.Tests</_Parameter1>
+        </AssemblyAttribute>
+    </ItemGroup>
 
 </Project>

ErsatzTV.Core/Jellyfin/JellyfinUrl.cs

@@ -63,5 +63,22 @@ namespace ErsatzTV.Core.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);
+        }
+
     }
 }

ErsatzTV.Core/Metadata/LocalStatisticsProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
@@ -126,7 +127,7 @@ namespace ErsatzTV.Core.Metadata
                 });
         }
 
-        private MediaVersion ProjectToMediaVersion(string path, FFprobe probeOutput) =>
+        internal MediaVersion ProjectToMediaVersion(string path, FFprobe probeOutput) =>
             Optional(probeOutput)
                 .Filter(json => json?.format != null && json.streams != null)
                 .ToValidation<BaseError>("Unable to parse ffprobe output")
@@ -137,7 +138,7 @@ namespace ErsatzTV.Core.Metadata
                         var version = new MediaVersion
                             { Name = "Main", DateAdded = DateTime.UtcNow, Streams = new List<MediaStream>() };
 
-                        if (double.TryParse(json.format.duration, out double duration))
+                        if (double.TryParse(json.format.duration, NumberStyles.Number, CultureInfo.InvariantCulture, out double duration))
                         {
                             var seconds = TimeSpan.FromSeconds(duration);
                             version.Duration = seconds;

ErsatzTV.Core/Metadata/MovieFolderScanner.cs

@@ -87,6 +87,7 @@ namespace ErsatzTV.Core.Metadata
 
                 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)))
@@ -157,6 +158,12 @@ namespace ErsatzTV.Core.Metadata
                     List<int> ids = await _movieRepository.DeleteByPath(libraryPath, path);
                     await _searchIndex.RemoveItems(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);
+                }
             }
 
             _searchIndex.Commit();

ErsatzTV.Core/Metadata/MusicVideoFolderScanner.cs

@@ -134,6 +134,12 @@ namespace ErsatzTV.Core.Metadata
                     List<int> musicVideoIds = await _musicVideoRepository.DeleteByPath(libraryPath, path);
                     await _searchIndex.RemoveItems(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);
+                }
             }
 
             List<int> artistIds = await _artistRepository.DeleteEmptyArtists(libraryPath);
@@ -238,6 +244,7 @@ namespace ErsatzTV.Core.Metadata
 
                 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)

ErsatzTV.Core/Metadata/TelevisionFolderScanner.cs

@@ -124,6 +124,11 @@ namespace ErsatzTV.Core.Metadata
                     _logger.LogInformation("Removing missing episode at {Path}", path);
                     await _televisionRepository.DeleteByPath(libraryPath, path);
                 }
+                else if (Path.GetFileName(path).StartsWith("._"))
+                {
+                    _logger.LogInformation("Removing dot underscore file at {Path}", path);
+                    await _televisionRepository.DeleteByPath(libraryPath, path);
+                }
             }
 
             await _televisionRepository.DeleteEmptySeasons(libraryPath);
@@ -201,7 +206,9 @@ namespace ErsatzTV.Core.Metadata
             string seasonPath)
         {
             foreach (string file in _localFileSystem.ListFiles(seasonPath)
-                .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f))).OrderBy(identity))
+                .Filter(f => VideoFileExtensions.Contains(Path.GetExtension(f)))
+                .Filter(f => !Path.GetFileName(f).StartsWith("._"))
+                .OrderBy(identity))
             {
                 // TODO: figure out how to rebuild playlists
                 Either<BaseError, Episode> maybeEpisode = await _televisionRepository

ErsatzTV.Core/Scheduling/MultiCollectionGrouper.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 
 namespace ErsatzTV.Core.Scheduling
 {
@@ -8,7 +9,7 @@ namespace ErsatzTV.Core.Scheduling
         {
             var result = new List<GroupedMediaItem>();
 
-            foreach (CollectionWithItems collection in collections)
+            foreach (CollectionWithItems collection in collections.Where(collection => collection.MediaItems.Any()))
             {
                 if (collection.ScheduleAsGroup)
                 {

ErsatzTV.Core/Scheduling/PlayoutBuilder.cs

@@ -403,8 +403,15 @@ namespace ErsatzTV.Core.Scheduling
             // remove any items outside the desired range
             playout.Items.RemoveAll(old => old.FinishOffset < playoutStart || old.StartOffset > playoutFinish);
 
-            DateTimeOffset maxStartTime = playout.Items.Max(i => i.FinishOffset);
-            DateTimeOffset minCurrentTime = maxStartTime < currentTime ? maxStartTime : currentTime;
+            DateTimeOffset minCurrentTime = currentTime;
+            if (playout.Items.Any())
+            {
+                DateTimeOffset maxStartTime = playout.Items.Max(i => i.FinishOffset);
+                if (maxStartTime < currentTime)
+                {
+                    minCurrentTime = maxStartTime;
+                }
+            }
             
             playout.Anchor = new PlayoutAnchor
             {
@@ -560,6 +567,10 @@ namespace ErsatzTV.Core.Scheduling
                     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);
@@ -586,6 +597,19 @@ namespace ErsatzTV.Core.Scheduling
                 : mediaItems.Map(mi => new GroupedMediaItem(mi, null)).ToList();
         }
 
+        private async Task<List<CollectionWithItems>> GetCollectionItemsForShuffleInOrder(CollectionKey collectionKey)
+        {
+            var result = new List<CollectionWithItems>();
+
+            if (collectionKey.MultiCollectionId != null)
+            {
+                result = await _mediaCollectionRepository.GetMultiCollectionCollections(
+                    collectionKey.MultiCollectionId.Value);
+            }
+
+            return result;
+        }
+
         private static string DisplayTitle(MediaItem mediaItem)
         {
             switch (mediaItem)

ErsatzTV.Core/Scheduling/ShuffleInOrderCollectionEnumerator.cs

@@ -0,0 +1,196 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Scheduling;
+using LanguageExt;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Core.Scheduling
+{
+    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)
+        {
+            _collections = collections;
+            _mediaItemCount = collections.Sum(c => c.MediaItems.Count);
+
+            if (state.Index >= _mediaItemCount)
+            {
+                state.Index = 0;
+                state.Seed = new Random(state.Seed).Next();
+            }
+            
+            _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()
+        {
+            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;
+        }
+        
+        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);
+                }
+
+                int offset = random.Next(ordered.Count);
+                result.Add(
+                    new OrderedCollection
+                    {
+                        Index = 0,
+                        Items = ordered.Skip(offset).Concat(ordered.Take(offset)).ToList()
+                    });
+            }
+
+            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; }
+        }
+    }
+}

ErsatzTV.Core/Scheduling/ShuffledMediaCollectionEnumerator.cs

@@ -73,9 +73,7 @@ namespace ErsatzTV.Core.Scheduling
             {
                 n--;
                 int k = random.Next(n + 1);
-                GroupedMediaItem value = copy[k];
-                copy[k] = copy[n];
-                copy[n] = value;
+                (copy[k], copy[n]) = (copy[n], copy[k]);
             }
 
             return GroupedMediaItem.FlattenGroups(copy, _mediaItemCount);

ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj

@@ -16,17 +16,17 @@
       <PackageReference Include="Lucene.Net" Version="4.8.0-beta00014" />
       <PackageReference Include="Lucene.Net.Analysis.Common" Version="4.8.0-beta00014" />
       <PackageReference Include="Lucene.Net.QueryParser" Version="4.8.0-beta00014" />
-      <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.8" />
-      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.8">
+      <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.9" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.9">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="5.0.8" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="5.0.9" />
       <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.10.56">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Refit" Version="6.0.38" />
+      <PackageReference Include="Refit" Version="6.0.94" />
       <PackageReference Include="SixLabors.ImageSharp" Version="1.0.3" />
     </ItemGroup>
 

ErsatzTV.Infrastructure/Plex/PlexServerApiClient.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
 using ErsatzTV.Core;
@@ -35,7 +36,12 @@ namespace ErsatzTV.Infrastructure.Plex
         {
             try
             {
-                IPlexServerApi service = RestService.For<IPlexServerApi>(connection.Uri);
+                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

ErsatzTV/Controllers/ArtworkController.cs

@@ -71,6 +71,7 @@ namespace ErsatzTV.Controllers
         [HttpGet("/artwork/posters/jellyfin/{*path}")]
         [HttpGet("/iptv/artwork/thumbnails/jellyfin/{*path}")]
         [HttpGet("/artwork/thumbnails/jellyfin/{*path}")]
+        [HttpGet("/artwork/fanart/jellyfin/{*path}")]
         public Task<IActionResult> GetJellyfin(string path)
         {
             if (Request.QueryString.HasValue)
@@ -85,6 +86,7 @@ namespace ErsatzTV.Controllers
         [HttpGet("/artwork/posters/emby/{*path}")]
         [HttpGet("/iptv/artwork/thumbnails/emby/{*path}")]
         [HttpGet("/artwork/thumbnails/emby/{*path}")]
+        [HttpGet("/artwork/fanart/emby/{*path}")]
         public Task<IActionResult> GetEmby(string path)
         {
             if (Request.QueryString.HasValue)

ErsatzTV/ErsatzTV.csproj

@@ -17,16 +17,16 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="Blazored.LocalStorage" Version="4.1.2" />
-      <PackageReference Include="FluentValidation" Version="10.3.0" />
-      <PackageReference Include="FluentValidation.AspNetCore" Version="10.3.0" />
-      <PackageReference Include="HtmlSanitizer" Version="5.0.404" />
+      <PackageReference Include="Blazored.LocalStorage" Version="4.1.5" />
+      <PackageReference Include="FluentValidation" Version="10.3.3" />
+      <PackageReference Include="FluentValidation.AspNetCore" Version="10.3.3" />
+      <PackageReference Include="HtmlSanitizer" Version="6.0.441" />
       <PackageReference Include="LanguageExt.Core" Version="3.4.15" />
-      <PackageReference Include="Markdig" Version="0.25.0" />
+      <PackageReference Include="Markdig" Version="0.26.0" />
       <PackageReference Include="MediatR.Courier.DependencyInjection" Version="3.0.1" />
       <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="9.0.0" />
-      <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="5.0.8" />
-      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.8">
+      <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="5.0.9" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.9">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
@@ -34,13 +34,13 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="MudBlazor" Version="5.0.15" />
+      <PackageReference Include="MudBlazor" Version="5.1.2" />
       <PackageReference Include="NaturalSort.Extension" Version="3.1.0" />
       <PackageReference Include="PPioli.FluentValidation.Blazor" Version="5.0.0" />
-      <PackageReference Include="Refit.HttpClientFactory" Version="6.0.38" />
+      <PackageReference Include="Refit.HttpClientFactory" Version="6.0.94" />
       <PackageReference Include="Serilog" Version="2.10.0" />
       <PackageReference Include="Serilog.AspNetCore" Version="4.1.0" />
-      <PackageReference Include="Serilog.Settings.Configuration" Version="3.1.0" />
+      <PackageReference Include="Serilog.Settings.Configuration" Version="3.2.0" />
       <PackageReference Include="Serilog.Sinks.SQLite" Version="5.0.0" />
       <PackageReference Include="System.IO.FileSystem.Primitives" Version="4.3.0" />
       <PackageReference Include="System.Text.Encoding.Extensions" Version="4.3.0" />

ErsatzTV/Pages/EmbyMediaSourceEditor.razor

@@ -1,4 +1,4 @@
-@page "/media/emby/edit"
+@page "/media/sources/emby/edit"
 @using Unit = LanguageExt.Unit
 @using ErsatzTV.Core.Emby
 @using ErsatzTV.Application.Emby.Queries

ErsatzTV/Pages/EmbyMediaSources.razor

@@ -1,4 +1,4 @@
-@page "/media/emby"
+@page "/media/sources/emby"
 @using ErsatzTV.Core.Interfaces.Emby
 @using ErsatzTV.Application.Emby.Commands
 @using ErsatzTV.Application.Emby.Queries

ErsatzTV/Pages/FFmpeg.razor

@@ -12,7 +12,7 @@
     <MudTable Hover="true" Items="_ffmpegProfiles">
         <ToolBarContent>
             <MudText Typo="Typo.h6">FFmpeg Profiles</MudText>
-            <MudToolBarSpacer></MudToolBarSpacer>
+            <MudSpacer/>
             <MudText Color="Color.Tertiary">Colored settings will be normalized</MudText>
         </ToolBarContent>
         <ColGroup>

ErsatzTV/Pages/JellyfinMediaSourceEditor.razor

@@ -1,4 +1,4 @@
-@page "/media/jellyfin/edit"
+@page "/media/sources/jellyfin/edit"
 @using Unit = LanguageExt.Unit
 @using ErsatzTV.Core.Jellyfin
 @using ErsatzTV.Application.Jellyfin.Queries

ErsatzTV/Pages/JellyfinMediaSources.razor

@@ -1,4 +1,4 @@
-@page "/media/jellyfin"
+@page "/media/sources/jellyfin"
 @using ErsatzTV.Core.Interfaces.Jellyfin
 @using ErsatzTV.Application.Jellyfin.Commands
 @using ErsatzTV.Application.Jellyfin.Queries

ErsatzTV/Pages/Libraries.razor

@@ -28,7 +28,7 @@
             <col/>
             <col/>
             <col/>
-            <col style="width: 240px;"/>
+            <col style="width: 180px;"/>
         </ColGroup>
         <HeaderContent>
             <MudTh>Library Kind</MudTh>
@@ -71,15 +71,6 @@
                                        Link="@($"/search?query=library_id%3a{context.Id}")">
                         </MudIconButton>
                     </MudTooltip>
-                    @if (context is LocalLibraryViewModel)
-                    {
-                        <MudTooltip Text="Edit Library">
-                            <MudIconButton Icon="@Icons.Material.Filled.Edit"
-                                           Disabled="@_locker.IsLibraryLocked(context.Id)"
-                                           Link="@($"/media/libraries/local/{context.Id}")">
-                            </MudIconButton>
-                        </MudTooltip>
-                    }
                 </div>
             </MudTd>
         </RowTemplate>

ErsatzTV/Pages/LocalLibraries.razor

@@ -0,0 +1,99 @@
+@page "/media/sources/local"
+@using ErsatzTV.Application.Libraries
+@using ErsatzTV.Application.Libraries.Commands
+@using ErsatzTV.Application.Libraries.Queries
+@implements IDisposable
+@inject IDialogService _dialog
+@inject IMediator _mediator
+@inject IEntityLocker _locker
+@inject ChannelWriter<IBackgroundServiceRequest> _workerChannel
+@inject ChannelWriter<IPlexBackgroundServiceRequest> _plexWorkerChannel
+@inject ChannelWriter<IJellyfinBackgroundServiceRequest> _jellyfinWorkerChannel
+@inject ChannelWriter<IEmbyBackgroundServiceRequest> _embyWorkerChannel
+
+<MudContainer MaxWidth="MaxWidth.ExtraLarge" Class="pt-8">
+    <MudTable Hover="true" Items="_libraries" Dense="true">
+        <ToolBarContent>
+            <MudText Typo="Typo.h6">Local Libraries</MudText>
+        </ToolBarContent>
+        <ColGroup>
+            <col/>
+            <col/>
+            <col style="width: 120px;"/>
+        </ColGroup>
+        <HeaderContent>
+            <MudTh>Name</MudTh>
+            <MudTh>Media Kind</MudTh>
+            <MudTh/>
+        </HeaderContent>
+        <RowTemplate>
+            <MudTd DataLabel="Name">@context.Name</MudTd>
+            <MudTd DataLabel="Media Kind">@context.MediaKind</MudTd>
+            <MudTd>
+                <div style="align-items: center; display: flex;">
+                    <MudTooltip Text="Edit Library">
+                        <MudIconButton Icon="@Icons.Material.Filled.Edit"
+                                       Disabled="@_locker.IsLibraryLocked(context.Id)"
+                                       Link="@($"/media/sources/local/{context.Id}/edit")">
+                        </MudIconButton>
+                    </MudTooltip>
+                    <MudTooltip Text="Delete Library">
+                        <MudIconButton Icon="@Icons.Material.Filled.Delete"
+                                       Disabled="@_locker.IsLibraryLocked(context.Id)"
+                                       OnClick="@(() => DeleteLibrary(context))">
+                        </MudIconButton>
+                    </MudTooltip>
+                </div>
+            </MudTd>
+        </RowTemplate>
+    </MudTable>
+    <MudButton Variant="Variant.Filled" Color="Color.Primary" Link="/media/sources/local/add" Class="mt-4">
+        Add Local Library
+    </MudButton>
+</MudContainer>
+
+@code {
+    private IList<LocalLibraryViewModel> _libraries;
+
+    protected override void OnInitialized()
+    {
+        _locker.OnLibraryChanged += LockChanged;
+    }
+
+    protected override async Task OnParametersSetAsync() => await LoadLibraries();
+
+    private async Task LoadLibraries()
+    {
+        _libraries = await _mediator.Send(new GetAllLocalLibraries());
+    }
+
+    private void LockChanged(object sender, EventArgs e) =>
+        InvokeAsync(StateHasChanged);
+
+    private async Task DeleteLibrary(LocalLibraryViewModel library)
+    {
+        int count = await _mediator.Send(new CountMediaItemsByLibrary(library.Id));
+        var parameters = new DialogParameters
+        {
+            { "EntityType", "library" },
+            { "EntityName", library.Name },
+            { "DetailText", $"This library contains {count} media items." },
+            { "DetailHighlight", count.ToString() }
+        };
+        var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };
+        
+        IDialogReference dialog = _dialog.Show<DeleteDialog>("Delete Library", parameters, options);
+        DialogResult result = await dialog.Result;
+        if (!result.Cancelled)
+        {
+            await _mediator.Send(new DeleteLocalLibrary(library.Id));
+            await LoadLibraries();
+        }
+    }
+
+    void IDisposable.Dispose()
+    {
+        _locker.OnLibraryChanged -= LockChanged;
+    }
+
+}

ErsatzTV/Pages/LocalLibraryEditor.razor

@@ -1,18 +1,53 @@
-@page "/media/libraries/local/{Id:int}"
+@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
+@implements IDisposable
 @inject IDialogService _dialog
+@inject IEntityLocker _locker
 @inject IMediator _mediator
+@inject ILogger<LocalLibraryEditor> _logger
+@inject ISnackbar _snackbar
+@inject NavigationManager _navigationManager
 
 <MudContainer MaxWidth="MaxWidth.ExtraLarge" Class="pt-8">
-    <MudTable Hover="true" Items="_libraryPaths" Dense="true">
+    <div style="max-width: 400px;">
+        <MudText Typo="Typo.h4" Class="mb-4">@(IsEdit ? "Edit Local Library" : "Add Local Library")</MudText>
+
+        <EditForm EditContext="_editContext" OnSubmit="@SaveChangesAsync">
+            <FluentValidator/>
+            <MudCard>
+                <MudCardContent>
+                    <MudTextField Class="mt-3" Label="Name" @bind-Value="_model.Name" For="@(() => _model.Name)"/>
+                    <MudSelect Disabled="IsEdit" Label="MediaKind" @bind-Value="_model.MediaKind" For="@(() => _model.MediaKind)">
+                        @foreach (LibraryMediaKind mediaKind in Enum.GetValues<LibraryMediaKind>())
+                        {
+                            <MudSelectItem Value="@mediaKind">@mediaKind</MudSelectItem>
+                        }
+                    </MudSelect>
+                    <MudTextField Class="mt-3" Label="Path" @bind-Value="_newPath.Path" For="@(() => _newPath.Path)"/>
+                </MudCardContent>
+                <MudCardActions>
+                    <MudButton Variant="Variant.Filled" Color="Color.Secondary" OnClick="@(_ => AddLibraryPath())" Class="ml-2">
+                        Add Path
+                    </MudButton>
+                    <MudButton ButtonType="ButtonType.Submit" Variant="Variant.Filled" Color="Color.Primary" Class="mr-2 ml-auto">
+                        Save Changes
+                    </MudButton>
+                </MudCardActions>
+            </MudCard>
+        </EditForm>
+    </div>
+
+    <MudTable Hover="true" Items="_model.Paths" Dense="true" Class="mt-6">
         <ToolBarContent>
             <MudText Typo="Typo.h6">Library Paths</MudText>
         </ToolBarContent>
         <ColGroup>
             <col/>
-            <col style="width: 60px;"/>
+            <col style="width: 120px;"/>
         </ColGroup>
         <HeaderContent>
             <MudTh>Path</MudTh>
@@ -22,6 +57,12 @@
             <MudTd DataLabel="Path">@context.Path</MudTd>
             <MudTd>
                 <div style="align-items: center; display: flex;">
+                    <MudTooltip Text="Move Library Path">
+                        <MudIconButton Icon="@Icons.Material.Filled.DriveFileMove"
+                                       Disabled="@(_model.Id == 0 || context.Id == 0 || _locker.IsLibraryLocked(_model.Id))"
+                                       OnClick="@(() => MoveLibraryPath(context))">
+                        </MudIconButton>
+                    </MudTooltip>
                     <MudTooltip Text="Delete Library Path">
                         <MudIconButton Icon="@Icons.Material.Filled.Delete"
                                        OnClick="@(() => DeleteLibraryPath(context))">
@@ -31,9 +72,6 @@
             </MudTd>
         </RowTemplate>
     </MudTable>
-    <MudButton Variant="Variant.Filled" Color="Color.Primary" Link="@($"/media/libraries/local/{Id}/add")" Class="mt-4">
-        Add Library Path
-    </MudButton>
 </MudContainer>
 
 
@@ -42,17 +80,94 @@
     [Parameter]
     public int Id { get; set; }
 
-    private IList<LocalLibraryPathViewModel> _libraryPaths;
+    private readonly LocalLibraryEditViewModel _model = new();
+    private LocalLibraryPathEditViewModel _newPath = new();
+    private EditContext _editContext;
+    private ValidationMessageStore _messageStore;
 
-    protected override async Task OnParametersSetAsync() => await LoadLibraryPaths();
+    private bool IsEdit => Id != 0;
 
-    private async Task LoadLibraryPaths() =>
-        _libraryPaths = await _mediator.Send(new GetLocalLibraryPaths(Id));
-
-    private async Task DeleteLibraryPath(LocalLibraryPathViewModel libraryPath)
+    protected override async Task OnParametersSetAsync()
     {
-        int count = await _mediator.Send(new CountMediaItemsByLibraryPath(libraryPath.Id));
+        if (IsEdit)
+        {
+            Option<LocalLibraryViewModel> maybeLibrary = await _mediator.Send(new GetLocalLibraryById(Id));
+            await maybeLibrary.Match(
+                async library =>
+                {
+                    _model.Id = library.Id;
+                    _model.Name = library.Name;
+                    _model.MediaKind = library.MediaKind;
 
+                    await LoadLibraryPaths();
+                },
+                () =>
+                {
+                    _navigationManager.NavigateTo("404");
+                    return Task.CompletedTask;
+                });
+        }
+        else
+        {
+            _model.HasChanges = true;
+            _model.Name = "New Local Library";
+            _model.MediaKind = LibraryMediaKind.Movies;
+            _model.Paths = new List<LocalLibraryPathEditViewModel>();
+        }
+    }
+
+    protected override void OnInitialized()
+    {
+        _locker.OnLibraryChanged += LockChanged;
+
+        _editContext = new EditContext(_model);
+        _messageStore = new ValidationMessageStore(_editContext);
+    }
+    
+    private void LockChanged(object sender, EventArgs e) =>
+        InvokeAsync(StateHasChanged);
+
+    private async Task LoadLibraryPaths()
+    {
+        _model.HasChanges = false;
+        _model.Paths = await _mediator.Send(new GetLocalLibraryPaths(Id))
+            .Map(list => list.Map(vm => new LocalLibraryPathEditViewModel
+            {
+                Id = vm.Id,
+                Path = vm.Path
+            }).ToList());
+    }
+
+    private async Task MoveLibraryPath(LocalLibraryPathEditViewModel libraryPath)
+    {
+        var parameters = new DialogParameters { { "MediaKind", _model.MediaKind }, { "SourceLibraryId", Id } };
+        var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };
+
+        IDialogReference dialog = _dialog.Show<MoveLocalLibraryPathDialog>("Move Local Library Path", parameters, options);
+        DialogResult result = await dialog.Result;
+        if (!result.Cancelled && result.Data is LocalLibraryViewModel library)
+        {
+            var request = new MoveLocalLibraryPath(libraryPath.Id, library.Id);
+            Either<BaseError, Unit> moveResult = await _mediator.Send(request);
+            moveResult.Match(
+                _ => _navigationManager.NavigateTo($"/media/sources/local/{library.Id}/edit"),
+                error =>
+                {
+                    _snackbar.Add(error.Value, Severity.Error);
+                    _logger.LogError("Unexpected error moving local library path: {Error}", error.Value);
+                });
+        }
+    }
+
+    private async Task DeleteLibraryPath(LocalLibraryPathEditViewModel libraryPath)
+    {
+        if (libraryPath.Id == 0)
+        {
+            _model.HasChanges = true;
+            _model.Paths.Remove(libraryPath);
+        }
+        
+        int count = await _mediator.Send(new CountMediaItemsByLibraryPath(libraryPath.Id));
         var parameters = new DialogParameters
         {
             { "EntityType", "library path" },
@@ -61,14 +176,65 @@
             { "DetailHighlight", count.ToString() }
         };
         var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };
-
+        
         IDialogReference dialog = _dialog.Show<DeleteDialog>("Delete Library Path", parameters, options);
         DialogResult result = await dialog.Result;
         if (!result.Cancelled)
         {
-            await _mediator.Send(new DeleteLocalLibraryPath(libraryPath.Id));
-            await LoadLibraryPaths();
+            _model.HasChanges = true;
+            _model.Paths.Remove(libraryPath);
         }
     }
 
+    private void AddLibraryPath()
+    {
+        if (_model.Paths.All(p => NormalizePath(p.Path) != NormalizePath(_newPath.Path)))
+        {
+            _model.HasChanges = true;
+            _model.Paths.Add(new LocalLibraryPathEditViewModel
+            {
+                Path = _newPath.Path
+            });
+        }
+
+        _newPath.Path = null;
+    }
+    
+    private async Task SaveChangesAsync()
+    {
+        _messageStore.Clear();
+        if (_editContext.Validate())
+        {
+            Either<BaseError, LocalLibraryViewModel> result = IsEdit
+                ? await _mediator.Send(new UpdateLocalLibrary(
+                    _model.Id,
+                    _model.Name,
+                    _model.Paths.Map(p => new UpdateLocalLibraryPath(p.Id, p.Path)).ToList()))
+                : await _mediator.Send(new CreateLocalLibrary(
+                    _model.Name,
+                    _model.MediaKind,
+                    _model.Paths.Map(p => p.Path).ToList()));
+
+            result.Match(
+                _ => _navigationManager.NavigateTo("/media/sources/local"),
+                error =>
+                {
+                    _snackbar.Add(error.Value, Severity.Error);
+                    _logger.LogError("Unexpected error saving local library: {Error}", error.Value);
+                });
+        }
+    }
+
+    private string NormalizePath(string path)
+    {
+        return Path.GetFullPath(new Uri(path).LocalPath)
+            .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
+            .ToUpperInvariant();
+    }
+
+    void IDisposable.Dispose()
+    {
+        _locker.OnLibraryChanged -= LockChanged;
+    }
+
 }

ErsatzTV/Pages/Movie.razor

@@ -161,7 +161,6 @@
         {
             <MediaCard Data="@actor"
                        Link="@(@$"actor:""{actor.Name.ToLowerInvariant()}""".GetRelativeSearchQuery())"
-                       IsRemoteArtwork="true"
                        ArtworkKind="ArtworkKind.Thumbnail"/>
         }
     </MudContainer>

ErsatzTV/Pages/PlexMediaSources.razor

@@ -1,4 +1,4 @@
-@page "/media/plex"
+@page "/media/sources/plex"
 @using ErsatzTV.Core.Interfaces.Plex
 @using ErsatzTV.Application.Plex
 @using ErsatzTV.Application.Plex.Commands
@@ -16,7 +16,7 @@
 <MudContainer MaxWidth="MaxWidth.ExtraLarge" Class="pt-8">
     <MudTable Hover="true" Dense="true" Items="_mediaSources">
         <ToolBarContent>
-            <MudText Typo="Typo.h6">Plex Media Source</MudText>
+            <MudText Typo="Typo.h6">Plex Media Sources</MudText>
         </ToolBarContent>
         <ColGroup>
             <col/>

ErsatzTV/Pages/ScheduleItemsEditor.razor

@@ -145,10 +145,17 @@
                                                  SearchFunc="@SearchArtists"
                                                  ToStringFunc="@(s => s?.Name)"/>
                             }
-                            <MudSelect Class="mt-3" Label="Playback Order" @bind-Value="@_selectedItem.PlaybackOrder" For="@(() => _selectedItem.PlaybackOrder)" Disabled="@(_selectedItem.CollectionType == ProgramScheduleItemCollectionType.MultiCollection)">
-                                @foreach (PlaybackOrder playbackOrder in Enum.GetValues<PlaybackOrder>())
+                            <MudSelect Class="mt-3" Label="Playback Order" @bind-Value="@_selectedItem.PlaybackOrder" For="@(() => _selectedItem.PlaybackOrder)">
+                                @if (_selectedItem.CollectionType == ProgramScheduleItemCollectionType.MultiCollection)
                                 {
-                                    <MudSelectItem Value="@playbackOrder">@playbackOrder</MudSelectItem>
+                                    <MudSelectItem Value="PlaybackOrder.Shuffle">Shuffle</MudSelectItem>
+                                    <MudSelectItem Value="PlaybackOrder.ShuffleInOrder">Shuffle In Order</MudSelectItem>
+                                }
+                                else
+                                {
+                                    <MudSelectItem Value="PlaybackOrder.Chronological">Chronological</MudSelectItem>
+                                    <MudSelectItem Value="PlaybackOrder.Random">Random</MudSelectItem>
+                                    <MudSelectItem Value="PlaybackOrder.Shuffle">Shuffle</MudSelectItem>
                                 }
                             </MudSelect>
                             <MudSelect Class="mt-3" Label="Playout Mode" @bind-Value="@_selectedItem.PlayoutMode" For="@(() => _selectedItem.PlayoutMode)">

ErsatzTV/Pages/TelevisionSeasonList.razor

@@ -162,7 +162,6 @@
         {
             <MediaCard Data="@actor"
                        Link="@(@$"actor:""{actor.Name.ToLowerInvariant()}""".GetRelativeSearchQuery())"
-                       IsRemoteArtwork="true"
                        ArtworkKind="ArtworkKind.Thumbnail"/>
         }
     </MudContainer>

ErsatzTV/Shared/MainLayout.razor

@@ -23,7 +23,7 @@
                           Class="search-bar">
             </MudTextField>
         </EditForm>
-        <MudAppBarSpacer/>
+        <MudSpacer/>
         <MudLink Color="Color.Info" Href="/iptv/channels.m3u" Target="_blank" Underline="Underline.None">M3U</MudLink>
         <MudLink Color="Color.Info" Href="/iptv/xmltv.xml" Target="_blank" Class="mx-4" Underline="Underline.None">XMLTV</MudLink>
         @* <MudLink Color="Color.Info" Href="/swagger" Target="_blank" Class="mr-4" Underline="Underline.None">API</MudLink> *@
@@ -43,9 +43,10 @@
             <MudNavLink Href="/ffmpeg">FFmpeg Profiles</MudNavLink>
             <MudNavLink Href="/watermarks">Watermarks</MudNavLink>
             <MudNavGroup Title="Media Sources" Expanded="true">
-                <MudNavLink Href="/media/emby">Emby</MudNavLink>
-                <MudNavLink Href="/media/jellyfin">Jellyfin</MudNavLink>
-                <MudNavLink Href="/media/plex">Plex</MudNavLink>
+                <MudNavLink Href="/media/sources/local">Local</MudNavLink>
+                <MudNavLink Href="/media/sources/emby">Emby</MudNavLink>
+                <MudNavLink Href="/media/sources/jellyfin">Jellyfin</MudNavLink>
+                <MudNavLink Href="/media/sources/plex">Plex</MudNavLink>
             </MudNavGroup>
             <MudNavGroup Title="Media" Expanded="true">
                 <MudNavLink Href="/media/libraries">Libraries</MudNavLink>

ErsatzTV/Shared/MoveLocalLibraryPathDialog.razor

@@ -0,0 +1,128 @@
+@using Microsoft.Extensions.Caching.Memory
+@using ErsatzTV.Application.Libraries
+@using ErsatzTV.Application.Libraries.Commands
+@using ErsatzTV.Application.Libraries.Queries
+@inject IMediator _mediator
+@inject IMemoryCache _memoryCache
+@inject ISnackbar _snackbar
+@inject ILogger<MoveLocalLibraryPathDialog> _logger
+
+<MudDialog>
+    <DialogContent>
+        <EditForm Model="@_dummyModel" OnSubmit="@(_ => Submit())">
+            <MudContainer Class="mb-6">
+                <MudText>
+                    Select the destination library
+                </MudText>
+            </MudContainer>
+            <MudSelect Label="Library" @bind-Value="_selectedLibrary" Class="mb-6 mx-4">
+                @foreach (LocalLibraryViewModel library in _libraries)
+                {
+                    <MudSelectItem Value="@library">@library.Name</MudSelectItem>
+                }
+            </MudSelect>
+            <MudTextFieldString Label="New Library Name"
+                                Disabled="@(_selectedLibrary != _newLibrary)"
+                                @bind-Text="@_newLibraryName"
+                                Class="mb-6 mx-4">
+            </MudTextFieldString>
+        </EditForm>
+    </DialogContent>
+    <DialogActions>
+        <MudButton OnClick="Cancel" ButtonType="ButtonType.Reset">Cancel</MudButton>
+        <MudButton Color="Color.Primary" Variant="Variant.Filled" OnClick="Submit">
+            Move To Library
+        </MudButton>
+    </DialogActions>
+</MudDialog>
+
+
+@code {
+
+    [CascadingParameter]
+    MudDialogInstance MudDialog { get; set; }
+
+    [Parameter]
+    public LibraryMediaKind MediaKind { get; set; }
+
+    [Parameter]
+    public int SourceLibraryId { get; set; }
+
+    private LocalLibraryViewModel _newLibrary;
+    private string _newLibraryName;
+
+    private List<LocalLibraryViewModel> _libraries;
+
+    private LocalLibraryViewModel _selectedLibrary;
+
+    private record DummyModel;
+
+    private readonly DummyModel _dummyModel = new();
+
+    private bool CanSubmit() =>
+        _selectedLibrary != null && (_selectedLibrary != _newLibrary || !string.IsNullOrWhiteSpace(_newLibraryName));
+
+    protected override async Task OnParametersSetAsync()
+    {
+        _newLibrary = new LocalLibraryViewModel(-1, "(New Library)", MediaKind);
+        
+        _libraries = await _mediator.Send(new GetAllLocalLibraries())
+            .Map(list => list.Filter(ll => ll.MediaKind == MediaKind && ll.Id != SourceLibraryId))
+            .Map(list => new[] { _newLibrary }.Append(list.OrderBy(vm => vm.Name, StringComparer.CurrentCultureIgnoreCase)).ToList());
+
+        if (_memoryCache.TryGetValue("MoveLocalLibraryPathDialog.SelectedLibraryId", out int id))
+        {
+            _selectedLibrary = _libraries.SingleOrDefault(c => c.Id == id) ?? _newLibrary;
+        }
+        else
+        {
+            _selectedLibrary = _newLibrary;
+        }
+    }
+
+    private async Task Submit()
+    {
+        if (!CanSubmit())
+        {
+            return;
+        }
+
+        if (_selectedLibrary == _newLibrary)
+        {
+            Either<BaseError, LocalLibraryViewModel> maybeResult =
+                await _mediator.Send(new CreateLocalLibrary(_newLibraryName, MediaKind, new List<string>()));
+
+            maybeResult.Match(
+                collection =>
+                {
+                    _memoryCache.Set("MoveLocalLibraryPathDialog.SelectedLibraryId", collection.Id);
+                    MudDialog.Close(DialogResult.Ok(collection));
+                },
+                error =>
+                {
+                    _snackbar.Add(error.Value, Severity.Error);
+                    _logger.LogError("Error creating new local library: {Error}", error.Value);
+                    MudDialog.Close(DialogResult.Cancel());
+                });
+        }
+        else
+        {
+            _memoryCache.Set("MoveLocalLibraryPathDialog.SelectedLibraryId", _selectedLibrary.Id);
+            MudDialog.Close(DialogResult.Ok(_selectedLibrary));
+        }
+    }
+
+    private async Task Cancel(MouseEventArgs e)
+    {
+    // this is gross, but [enter] seems to sometimes trigger cancel instead of submit
+        if (e.Detail == 0)
+        {
+            await Submit();
+        }
+        else
+        {
+            MudDialog.Cancel();
+        }
+    }
+
+}

ErsatzTV/Shared/RemoteMediaSourceEditor.razor

@@ -54,7 +54,7 @@
         {
             Either<BaseError, Unit> result = await SaveSecrets(_model);
             result.Match(
-                _ => _navigationManager.NavigateTo($"/media/{Name.ToLowerInvariant()}"),
+                _ => _navigationManager.NavigateTo($"/media/sources/{Name.ToLowerInvariant()}"),
                 error =>
                 {
                     _snackbar.Add(error.Value, Severity.Error);

ErsatzTV/Shared/RemoteMediaSourceLibrariesEditor.razor

@@ -105,7 +105,7 @@
                     }
                 }
 
-                _navigationManager.NavigateTo($"/media/{Name.ToLowerInvariant()}");
+                _navigationManager.NavigateTo($"/media/sources/{Name.ToLowerInvariant()}");
             });
     }
 

ErsatzTV/Shared/RemoteMediaSourcePathReplacementsEditor.razor

@@ -132,7 +132,7 @@
                 _snackbar.Add($"Unexpected error saving path replacements: {error.Value}", Severity.Error);
                 _logger.LogError("Unexpected error saving path replacements: {Error}", error.Value);
             },
-            () => _navigationManager.NavigateTo($"/media/{Name.ToLowerInvariant()}"));
+            () => _navigationManager.NavigateTo($"/media/sources/{Name.ToLowerInvariant()}"));
     }
 
 }

ErsatzTV/Shared/RemoteMediaSources.razor

@@ -10,7 +10,7 @@
 <MudContainer MaxWidth="MaxWidth.ExtraLarge" Class="pt-8">
     <MudTable Hover="true" Dense="true" Items="_mediaSources">
         <ToolBarContent>
-            <MudText Typo="Typo.h6">@Name Media Source</MudText>
+            <MudText Typo="Typo.h6">@Name Media Sources</MudText>
         </ToolBarContent>
         <ColGroup>
             <col/>
@@ -60,7 +60,7 @@
     {
         <MudButton Variant="Variant.Filled"
                    Color="Color.Primary"
-                   Link="@($"/media/{Name.ToLowerInvariant()}/edit")"
+                   Link="@($"/media/sources/{Name.ToLowerInvariant()}/edit")"
                    Class="mt-4">
             Connect @Name
         </MudButton>
@@ -70,7 +70,7 @@
     {
         <MudButton Variant="Variant.Filled"
                    Color="Color.Secondary"
-                   Link="@($"/media/{Name.ToLowerInvariant()}/edit")"
+                   Link="@($"/media/sources/{Name.ToLowerInvariant()}/edit")"
                    Class="ml-4 mt-4">
             Fix @Name Connection
         </MudButton>

ErsatzTV/Validators/LocalLibraryEditViewModelValidator.cs

@@ -0,0 +1,10 @@
+using ErsatzTV.ViewModels;
+using FluentValidation;
+
+namespace ErsatzTV.Validators
+{
+    public class LocalLibraryEditViewModelValidator : AbstractValidator<LocalLibraryEditViewModel>
+    {
+        public LocalLibraryEditViewModelValidator() => RuleFor(c => c.Name).NotEmpty();
+    }
+}

ErsatzTV/ViewModels/LocalLibraryEditViewModel.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.ViewModels
+{
+    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; }
+    }
+}

ErsatzTV/ViewModels/LocalLibraryPathEditViewModel.cs

@@ -2,6 +2,7 @@
 {
     public class LocalLibraryPathEditViewModel
     {
+        public int Id { get; set; }
         public string Path { get; set; }
     }
 }

ErsatzTV/wwwroot/css/site.css

@@ -132,7 +132,7 @@
 
 .release-notes h3 { margin-top: 20px; }
 
-.mud-table-container { overflow-x: unset; }
+.mud-table-container { overflow-x: unset; overflow-y: unset; }
 
 #blazor-error-ui { color: black; }
 #blazor-error-ui a { color: unset; }

docs/index.md

@@ -1,6 +1,6 @@
-![ErsatzTV](../images/ersatztv.png)
+![ErsatzTV](images/ersatztv.png)
 
-**ErsatzTV** is pre-alpha software for configuring and streaming custom live channels using your media library. The software is currently unstable and under active development.
+**ErsatzTV** is alpha software for configuring and streaming custom live channels using your media library. The software is currently unstable and under active development.
 
 Want to join the community or have a question? Join us on [Discord](https://discord.gg/hHaJm3yGy6).
 

docs/user-guide/add-media-items.md

@@ -3,23 +3,30 @@ Four library kinds are currently supported: [Local](#local-libraries), [Plex](#p
 
 ## Local Libraries
 
-ErsatzTV provides three local libraries, one for each supported media kind: `Movies`, `Shows` and `Music Videos`.
+Local libraries provide a way to schedule media directly from folders; no media server is necessary.
 
 ### Metadata
 
 With local libraries, ErsatzTV will read metadata from [NFO files](https://kodi.wiki/view/NFO_files), falling back to a *minimal* amount of metadata if NFO files are not found.
 
+### Add Libraries
+
+ErsatzTV provides three local libraries by default, one for each supported media kind: `Movies`, `Shows` and `Music Videos`.
+Additional libraries can be added under `Media Sources` > `Local`.
+
 ### Add Media Items
 
-To add media items to a local library under `Media` > `Libraries`, click the edit button for the library:
+To add media items to a local library under `Media Sources` > `Local`, click the edit button for the library:
 
-![Libraries Edit Icon](../images/libraries-edit-icon.png)
+![Local Libraries Edit Icon](../images/local-libraries-edit-icon.png)
 
-Then click the `Add Library Path` button and enter the path where your media files of the appropriate kind are stored:
+In the `Path` field, enter the path where your media files of the appropriate kind are stored:
 
 ![Add Local Library Path](../images/shows-add-local-library-path.png)
 
-Finally, click `Add Local Library Path` and ErsatzTV will scan and import your media items.
+Finally, click `Add Path`.
+
+When you have added all of your media paths, click `Save Changes` and ErsatzTV will scan and import your media items.
 
 ## Plex Libraries
 

docs/user-guide/create-channels.md

@@ -8,9 +8,10 @@ Channel numbers can be whole numbers or can contain one decimal, like `500` or `
 
 ### Streaming Mode
 
-Two streaming modes are currently supported: `MPEG-TS` (Transport Stream) and `HLS Direct` (HTTP Live Streaming Direct).
-`MPEG-TS` is considered stable and is recommended for most purposes.
-`HLS Direct` is unstable and is not recommended for general use, but can avoid the need to transcode with some clients.
+Three streaming modes are currently supported: `MPEG-TS` (Transport Stream), `HLS Direct` (HTTP Live Streaming Direct) and `HLS Hybrid` (HTTP Live Streaming Hybrid).
+* `MPEG-TS` transcodes content and supports watermarks, though some clients will have issues at program boundaries
+* `HLS Direct` does not transcode content and can perform better on low power systems, but does not support watermarks
+* `HLS Hybrid` transcodes content and supports watermarks, and can perform very well at program boundaries with some clients
 
 ### FFmpeg Profile
 
@@ -24,15 +25,10 @@ Channel logos can be added using the `Upload Logo` button and the logos will dis
 ## Create Schedule
 
 Schedules are used to control the playback order of media items on a channel.
-Create a Schedule by navigating to the `Schedules` page, clicking `Add Schedule` and giving your schedule a name, a collection playback order, and clicking `Add Schedule` to confirm your selections.
+Create a Schedule by navigating to the `Schedules` page, clicking `Add Schedule` and giving your schedule a name, and selecting the appropriate settings:
 
-### Collection Playback Order
-
-Select the desired playback order for media items within each collection in the schedule:
-
-- `Chronological`: Items are ordered by release date, then by season and episode number.
-- `Random`: Items are randomly ordered and may contain repeats.
-- `Shuffle`: Items are randomly ordered and no item will be played a second time until every item from the collection has been played once.
+* `Keep Multi-Part Episodes Together`: This only applies to shuffled schedule items, and will try to intelligently group multi-part episodes (i.e. `s05e02 - whatever part 1` and `s05e03 - whatever part 2`) so they are always scheduled together and always play in the correct order.
+* `Treat Collections As Shows`: This only applies when `Keep Multi-Part Episodes Together` is enabled, and will try to group multi-part episodes across shows within the collection (i.e. crossover episodes like `Show 1 - s03e04 - Whatever Part 1` and `Show 2 - s01e07 - Whatever Part 2`).
 
 ### Schedule Items
 
@@ -56,11 +52,20 @@ Schedule items can contain the following collection types:
 - `Television Show`: Select an entire television show.
 - `Television Season`: Select a specific season of a television show.
 - `Artist`: Select all music videos for a specific artist.
+- `Multi Collection`: Select all collections within a multi-collection.
 
 #### Collection
 
 Based on the selected collection type, select the desired collection.
 
+### Playback Order
+
+Select the desired playback order for media items within the selected collection:
+
+- `Chronological`: Items are ordered by release date, then by season and episode number.
+- `Random`: Items are randomly ordered and may contain repeats.
+- `Shuffle`: Items are randomly ordered and no item will be played a second time until every item from the collection has been played once.
+
 #### Playout Mode
 
 Select how you want this schedule item to behave every time it is selected for playback.