update changelog for release v0.3.4-alpha [no ci]

allow ffmpeg reports on windows (#547 )
* enable troubleshooting reports on windows * update changelog * tweak changelog
2021-12-21 09:46:43 -06:00 · 2021-12-21 09:27:49 -06:00 · 2021-12-21 08:52:51 -06:00 · 2021-12-17 08:48:40 -06:00 · 2021-12-14 14:27:12 -06:00 · 2021-12-13 06:25:37 -06:00
535 changed files with 173558 additions and 3080 deletions
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -3,7 +3,7 @@
  "isRoot": true,
  "tools": {
    "jetbrains.resharper.globaltools": {
-      "version": "2021.1.3",
+      "version": "2021.2.2",
      "commands": [
        "jb"
      ]
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -19,7 +19,7 @@ jobs:
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v1
        with:
-          dotnet-version: 5.0.x
+          dotnet-version: 6.0.x

      - name: Clean
        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -49,7 +49,7 @@ jobs:
          tag=$(git describe --tags --abbrev=0)
          tag2="${tag:1}"
          short=$(git rev-parse --short HEAD)
-          final="${tag2/prealpha/$short}"
+          final="${tag2/alpha/$short}"
          echo "GIT_TAG=${final}" >> $GITHUB_ENV

      - name: Set up Docker Buildx Base
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -1,71 +0,0 @@
-# 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
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -10,7 +10,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout master
-        uses: actions/checkout@v1
+        uses: actions/checkout@v2

      - name: Deploy docs
        uses: mhausenblas/mkdocs-deploy-gh-pages@master
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -18,8 +18,11 @@ jobs:
            kind: windows
            target: win-x64
          - os: macos-latest
-            kind: maxOS
+            kind: macOS
            target: osx-x64
+          - os: macos-latest
+            kind: macOS
+            target: osx-arm64
    runs-on: ${{ matrix.os }}
    steps:
      - name: Get the sources
@@ -28,7 +31,7 @@ jobs:
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v1
        with:
-          dotnet-version: 5.0.x
+          dotnet-version: 6.0.x

      - name: Clean
        run: dotnet clean --configuration Release && dotnet nuget locals all --clear
@@ -44,14 +47,11 @@ jobs:
          release_name="ErsatzTV-$tag-${{ matrix.target }}"

          # Build everything
-          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net5.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}" /property:PublishSingleFile=true --self-contained true
+          dotnet publish ErsatzTV/ErsatzTV.csproj --framework net6.0 --runtime "${{ matrix.target }}" -c Release -o "$release_name" /property:InformationalVersion="${tag:1}-${{ matrix.target }}" /property:EnableCompressionInSingleFile=true /property:PublishSingleFile=true --self-contained true

          # Pack files
          if [ "${{ matrix.target }}" == "win-x64" ]; then
            7z a -tzip "${release_name}.zip" "./${release_name}/*"
-          elif [ "${{ matrix.target }}" == "linux-arm" ]; then
-            cp lib/linux-arm/* "$release_name/"
-            tar czvf "${release_name}.tar.gz" "$release_name"
          else
            tar czvf "${release_name}.tar.gz" "$release_name"
          fi
@@ -82,7 +82,7 @@ jobs:
        run: |
          tag=$(git describe --tags --abbrev=0)
          echo "GIT_TAG=${tag:1}" >> $GITHUB_ENV
-          echo "DOCKER_TAG=${tag/-prealpha/}" >> $GITHUB_ENV
+          echo "DOCKER_TAG=${tag/-alpha/}" >> $GITHUB_ENV

      - name: Set up Docker Buildx Base
        uses: docker/setup-buildx-action@v1
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,293 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

 ## [Unreleased]

+## [0.3.4-alpha] - 2021-12-21
+### Fixed
+- Fix other video and song scanners to include videos contained directly in top-level folders that are added to a library
+- Allow saving ffmpeg troubleshooting reports on Windows
+
+## [0.3.3-alpha] - 2021-12-12
+### Fixed
+- Fix bug with saving multiple blurhash versions for cover art; all cover art will be automatically rescanned
+- Fix song detail margin when no cover art exists and no watermark exists
+- Fix synchronizing virtual shows and seasons from Jellyfin
+- Properly sort channels in M3U
+
+### Changed
+- Use blurhash of ErsatzTV colors instead of solid colors for default song backgrounds
+- Use select control instead of autocomplete control in many places
+    - The autocomplete control is not intuitive to use and has focus bugs
+
+## [0.3.2-alpha] - 2021-12-03
+### Fixed
+- Fix artwork upload on Windows
+- Fix unicode song metadata on Windows
+- Fix unicode console output on Windows
+- Fix TV Show NFO metadata processing when `year` is missing
+- Fix song detail outline to help legibility on white backgrounds
+- Optimize song artwork scanning to prevent re-processing album artwork for each song
+
+### Changed
+- Use custom log database backend which should be more portable (i.e. work in osx-arm64)
+- Use cover art blurhashes for song backgrounds instead of solid colors or box blur
+
+## [0.3.1-alpha] - 2021-11-30
+### Fixed
+- Fix song page links in UI
+- Show song artist in playout detail
+- Include song artist and cover art in channel guide (xmltv)
+- Use subtitles to display errors, which fixes many edge cases of unescaped characters
+- Properly split song genre tags
+- Properly display all songs that have an identical album and title
+- Fix channel logo and watermark uploads
+- Fix regression introduced with `v0.2.4-alpha` that caused some filler edge cases to crash the playout builder
+
+### Added
+- Add song genres to search index
+- Use embedded song cover art when sidecar cover art is unavailable
+
+### Changed
+- Randomly place song cover art on left or right side of screen
+- Randomly use a solid color from the cover art instead of blurred cover art for song background
+- Randomly select song detail layout (large title/small artist or small artist/title/album)
+
+## [0.3.0-alpha] - 2021-11-25
+### Fixed
+- Properly fix database incompatibility introduced with `v0.2.4-alpha` and partially fixed with `v0.2.5-alpha`
+  - The proper fix requires rebuilding all playouts, which will happen on startup after upgrading
+- Fix local library locking/progress display when adding paths
+- Fix grouping duration items in EPG when custom title is configured
+
+### Added
+- Add *experimental* `Songs` local libraries
+    - Like `Other Videos`, `Songs` require no metadata or particular folder layout, and will have tags added for each containing folder
+    - For Example, a song at `rock/band/1990 - Album/01 whatever.flac` will have the tags `rock`, `band` and `1990 - Album`, and the title `01 whatever`
+    - Songs will also have basic metadata read from embedded tags (album, artist, title)
+    - Video will be automatically generated for songs using metadata and cover art or watermarks if available
+- Add support for `.webm` video files
+
+## [0.2.5-alpha] - 2021-11-21
+### Fixed
+- Include other video title in channel guide (xmltv)
+- Fix bug introduced with 0.2.4-alpha that caused some playouts to build from year 0
+- Use less memory matching Trakt list items
+
+### Added
+- Build osx-arm64 packages on release
+
+### Changed
+- No longer warn about local Plex guids; they aren't used for Trakt matching and can be ignored
+
+## [0.2.4-alpha] - 2021-11-13
+### Changed
+- Upgrade to dotnet 6
+- Use `scale_cuda` instead of `scale_npp` for NVIDIA scaling in all cases
+
+## [0.2.3-alpha] - 2021-11-03
+### Fixed
+- Fix bug with audio filter in cultures where `.` is a group/thousands separator
+- Fix bug where flood playout mode would only schedule one item
+  - This would happen if the flood was followed by another flood with a fixed start time
+
+### Added
+- Support empty `.etvignore` file to instruct local movie scanner to ignore the containing folder
+
+## [0.2.2-alpha] - 2021-10-30
+### Fixed
+- Fix EPG entries for Duration schedule items that play multiple items
+- Fix EPG entries for Multiple schedule items that play more than one item
+
+### Added
+- Add fallback filler settings to Channel and global FFmpeg Settings
+  - When streaming is attempted during an unscheduled gap, the resulting video will be determined using the following priority:
+    - Channel fallback filler
+    - Global fallback filler
+    - Generated `Channel Is Offline` error message video 
+
+### Changed
+- Allow per-episode folders for local show libraries
+  - e.g. `Show Name\Season #\Episode #\Show Name - s#e#.mkv`
+
+## [0.2.1-alpha] - 2021-10-24
+### Fixed
+- Fix saving dynamic start time on schedule items
+
+## [0.2.0-alpha] - 2021-10-23
+### Fixed
+- Fix generated streams with mpeg2video
+- Fix incorrect row count in playout detail table
+- Fix deleting movies that have been removed from Jellyfin and Emby
+- Fix bug that caused large unscheduled gaps in playouts
+  - This was caused by schedule items with a fixed start of midnight
+
+### Added
+- Add new filler system
+    - `Pre-Roll Filler` plays before each media item
+    - `Mid-Roll Filler` plays between media item chapters
+    - `Post-Roll Filler` plays after each media item
+    - `Tail Filler` plays after all media items, until the next media item
+    - `Fallback Filler` loops instead of default offline image to fill any remaining gaps
+- Store chapter details with media statistics; this is needed to support mid-roll filler
+    - This requires re-ingesting statistics for all media items the first time this version is launched
+- Add switch to show/hide filler in playout detail table
+- Add `minutes` field to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Change some debug log messages to info so they show by default again
+- Remove tail collection options from `Duration` playout mode
+- Show localized start time in schedule items tables
+
+## [0.1.5-alpha] - 2021-10-18
+### Fixed
+- Fix double scheduling; this could happen if the app was shutdown during a playout build
+- Fix updating Jellyfin and Emby TV seasons
+- Fix updating Jellyfin and Emby artwork
+- Fix Plex, Jellyfin, Emby worker crash attempting to sync library that no longer exists
+- Fix bug with `Duration` mode scheduling when media items are too long to fit in the requested duration
+
+### Added
+- Include music video thumbnails in channel guide (xmltv)
+
+### Changed
+- Automatically find working Plex address on startup
+- Automatically select schedule item in schedules that contain only one item
+- Change default log level from `Debug` to `Information`
+  - The `Debug` log level can be enabled in the `appsettings.json` file for non-docker installs
+  - The `Debug` log level can be enabled by setting the environment variable `Serilog:MinimumLevel=Debug` for docker installs
+
+## [0.1.4-alpha] - 2021-10-14
+### Fixed
+- Fix error message/offline stream continuity with channels that use HLS Segmenter
+- Fix removing items from search index when folders are removed from local libraries
+
+### Added
+- Add `Other Video` local libraries
+  - Other video items require no metadata or particular folder layout, and will have tags added for each containing folder
+  - For Example, a video at `commercials/sd/1990/whatever.mkv` will have the tags `commercials`, `sd` and `1990`, and the title `whatever`
+- Add filler `Tail Mode` option to `Duration` playout mode (in addition to existing `Offline` option)
+  - Filler collection will always be randomized (to fill as much time as possible)
+  - Filler will be hidden from channel guide, but visible in playout details in ErsatzTV
+  - Unfilled time will show offline image
+- Add `Guide Mode` option to all schedule items
+  - `Normal` guide mode will show all scheduled items in the channel guide (xmltv)
+  - `Filler` guide mode will hide all scheduled items from the channel guide, and extend the end time for the previous item in the guide
+
+## [0.1.3-alpha] - 2021-10-13
+### Fixed
+- Fix startup bug for some docker installations
+
+## [0.1.2-alpha] - 2021-10-12
+### Added
+- Include more cuda (nvidia) filters in docker image
+- Enable deinterlacing with nvidia using new `yadif_cuda` filter
+- Add two HLS Segmenter settings: idle timeout and work-ahead limit
+  - `HLS Segmenter Idle Timeout` - the number of seconds to keep transcoding a channel while no requests have been received from any client
+    - This setting must be greater than or equal to 30 (seconds)
+  - `Work-Ahead HLS Segmenter Limit` - the number of segmenters (channels) that will work-ahead simultaneously (if multiple channels are being watched)
+    - "working ahead" means transcoding at full speed, which can take a lot of resources
+    - This setting must be greater than or equal to 0
+- Add more watermark locations ("middle" of each side)
+- Add `VAAPI Device` setting to ffmpeg profile to support installations with multiple video cards
+- Add *experimental* `RadeonSI` option for `VAAPI Driver` and include mesa drivers in vaapi docker image
+
+### Changed
+- Upgrade ffmpeg from 4.3 to 4.4 in all docker images
+  - Upgrading from 4.3 to 4.4 is recommended for all installations
+- Move `VAAPI Driver` from settings page to ffmpeg profile to support installations with multiple video cards
+
+### Fixed
+- Fix some transcoding edge cases with nvidia and pixel format `yuv420p10le`
+
+## [0.1.1-alpha] - 2021-10-10
+### Added
+- Add music video album to search index
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Changed
+- Remove forced initial delay from `HLS Segmenter` streaming mode
+- Upgrade nvidia docker image from 18.04 to 20.04
+
+## [0.1.0-alpha] - 2021-10-08
+### Added
+- Add *experimental* streaming mode `HLS Segmenter` (most similar to `HLS Hybrid`) 
+  - This mode is intended to increase client compatibility and reduce issues at program boundaries
+  - If you want the temporary transcode files to be located on a particular drive, the docker path is `/root/.local/share/etv-transcode`
+- Store frame rate with media statistics; this is needed to support HLS Segmenter
+  - This requires re-ingesting statistics for all media items the first time this version is launched
+
+### Changed
+- Use latest iHD driver (21.2.3 vs 20.1.1) in vaapi docker images
+
+### Fixed
+- Add downsampling to support transcoding 10-bit HEVC content with the h264_vaapi encoder
+- Fix updating statistics when media items are replaced
+- Fix XMLTV generation when scheduled episode is missing metadata
+
+## [0.0.62-alpha] - 2021-10-05
+### Added
+- Support IMDB ids from Plex libraries, which may improve Trakt matching for some items
+
+### Fixed
+- Include Specials/Season 0 `episode-num` entry in XMLTV
+- Fix some transcoding edge cases with VAAPI and pixel formats `yuv420p10le`, `yuv444p10le` and `yuv444p`
+- Update Plex movie and episode paths when they are changed within Plex
+- Always use `libx264` software encoder for error messages
+
+## [0.0.61-alpha] - 2021-09-30
+### Fixed
+- Revert nvenc/cuda filter change from v60
+
+## [0.0.60-alpha] - 2021-09-25
+### Added
+- Add Trakt list support under `Lists` > `Trakt Lists`
+  - Trakt lists can be added by url or by `user/list`
+  - To re-download a Trakt list, simply add it again (no need to delete)
+  - See `Logs` for unmatched item details
+  - Trakt lists can only be scheduled by using Smart Collections
+- Add seasons to search index
+  - This is needed because Trakt lists can contain seasons 
+  - This requires rebuilding the search index and search results may be empty or incomplete until the rebuild is complete
+
+### Fixed
+- Fix local television scanner to properly update episode metadata when NFO files have been added/changed
+- Properly detect ffmpeg nvenc (cuda) support in Hardware Acceleration health check
+- Fix nvenc/cuda filter for some yuv420p content
+
+## [0.0.59-alpha] - 2021-09-18
+### Added
+- Add `Health Checks` table to home page to identify and surface common misconfigurations
+  - `FFmpeg Version` checks `ffmpeg` and `ffprobe` versions
+  - `FFmpeg Reports` checks whether ffmpeg troubleshooting reports are enabled since they can use a lot of disk space over time
+  - `Hardware Acceleration` checks whether channels that transcode are using acceleration methods that ffmpeg claims to support
+  - `Movie Metadata` checks whether all movies have metadata (fallback metadata counts as metadata)
+  - `Episode Metadata` checks whether all episodes have metadata (fallback metadata counts as metadata)
+  - `Zero Duration` checks whether all movies and episodes have a valid (non-zero) duration
+  - `VAAPI Driver` checks whether a vaapi driver preference is configured when using the vaapi docker image
+- Add setting to each playout to schedule an automatic daily rebuild
+  - This is useful if the playout uses a smart collection with `released_onthisday`
+
+### Fixed
+- Fix docker vaapi support for newer Intel platforms (Gen 8+)
+  - This includes a new setting to force a particular vaapi driver (`iHD` or `i965`), as some Gen 8 or 9 hardware that is supported by both drivers will perform better with one or the other
+- Fix scanning and indexing local movies and episodes without NFO metadata
+- Fix displaying seasons for shows with no year (in metadata or in folder name)
+- Fix "direct play" in MPEG-TS mode (copy audio and video stream when `Transcode` is unchecked)
+
+## [0.0.58-alpha] - 2021-09-15
+### Added
+- Add `released_notinthelast` search field for relative release date queries
+  - Syntax is a number and a unit (days, weeks, months, years) like `1 week` or `2 years`
+- Add `released_onthisday` search field for historical queries
+  - Syntax is `released_onthisday:1` and will search for items released on this month number and day number in prior years
+- Add tooltip explaining `Keep Multi-Part Episodes Together`
+
+### Fixed
+- Properly display watermark when no other video filters (like scaling or padding) are required
+- Fix building some playouts in timezones with positive offsets (like UTC+2)
+- Fix `Shuffle In Order` so all collections/shows start from the earliest episode
+  - You may need to rebuild playouts to see this fixed behavior more quickly
+
 ## [0.0.57-alpha] - 2021-09-10
 ### Added
 - Add `released_inthelast` search field for relative release date queries
@@ -580,7 +867,29 @@ 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.57-alpha...HEAD
+[Unreleased]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.4-alpha...HEAD
+[0.3.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.3-alpha...v0.3.4-alpha
+[0.3.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.2-alpha...v0.3.3-alpha
+[0.3.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.1-alpha...v0.3.2-alpha
+[0.3.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.3.0-alpha...v0.3.1-alpha
+[0.3.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.5-alpha...v0.3.0-alpha
+[0.2.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.4-alpha...v0.2.5-alpha
+[0.2.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.3-alpha...v0.2.4-alpha
+[0.2.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.2-alpha...v0.2.3-alpha
+[0.2.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.1-alpha...v0.2.2-alpha
+[0.2.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.2.0-alpha...v0.2.1-alpha
+[0.2.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.5-alpha...v0.2.0-alpha
+[0.1.5-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.4-alpha...v0.1.5-alpha
+[0.1.4-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.3-alpha...v0.1.4-alpha
+[0.1.3-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.2-alpha...v0.1.3-alpha
+[0.1.2-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.1-alpha...v0.1.2-alpha
+[0.1.1-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.1.0-alpha...v0.1.1-alpha
+[0.1.0-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.62-alpha...v0.1.0-alpha
+[0.0.62-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.61-alpha...v0.0.62-alpha
+[0.0.61-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.60-alpha...v0.0.61-alpha
+[0.0.60-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.59-alpha...v0.0.60-alpha
+[0.0.59-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.58-alpha...v0.0.59-alpha
+[0.0.58-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.57-alpha...v0.0.58-alpha
 [0.0.57-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.56-alpha...v0.0.57-alpha
 [0.0.56-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.55-alpha...v0.0.56-alpha
 [0.0.55-alpha]: https://github.com/jasongdove/ErsatzTV/compare/v0.0.54-alpha...v0.0.55-alpha
--- a/ErsatzTV.Application/Channels/ChannelViewModel.cs
+++ b/ErsatzTV.Application/Channels/ChannelViewModel.cs
@@ -10,5 +10,7 @@ namespace ErsatzTV.Application.Channels
        string Logo,
        string PreferredLanguageCode,
        StreamingMode StreamingMode,
-        int? WatermarkId);
+        int? WatermarkId,
+        int? FallbackFillerId,
+        int PlayoutCount);
 }
--- a/ErsatzTV.Application/Channels/Commands/CreateChannel.cs
+++ b/ErsatzTV.Application/Channels/Commands/CreateChannel.cs
@@ -13,5 +13,6 @@ namespace ErsatzTV.Application.Channels.Commands
        string Logo,
        string PreferredLanguageCode,
        StreamingMode StreamingMode,
-        int? WatermarkId) : IRequest<Either<BaseError, CreateChannelResult>>;
+        int? WatermarkId,
+        int? FallbackFillerId) : IRequest<Either<BaseError, CreateChannelResult>>;
 }
--- a/ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs
+++ b/ErsatzTV.Application/Channels/Commands/CreateChannelHandler.cs
@@ -7,6 +7,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using LanguageExt;
@@ -42,9 +43,10 @@ namespace ErsatzTV.Application.Channels.Commands
            (ValidateName(request), await ValidateNumber(dbContext, request),
                await FFmpegProfileMustExist(dbContext, request),
                ValidatePreferredLanguage(request),
-                await WatermarkMustExist(dbContext, request))
+                await WatermarkMustExist(dbContext, request),
+                await FillerPresetMustExist(dbContext, request))
            .Apply(
-                (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId) =>
+                (name, number, ffmpegProfileId, preferredLanguageCode, watermarkId, fillerPresetId) =>
                {
                    var artwork = new List<Artwork>();
                    if (!string.IsNullOrWhiteSpace(request.Logo))
@@ -74,6 +76,11 @@ namespace ErsatzTV.Application.Channels.Commands
                        channel.WatermarkId = id;
                    }

+                    foreach (int id in fillerPresetId)
+                    {
+                        channel.FallbackFillerId = id;
+                    }
+
                    return channel;
                });

@@ -131,5 +138,25 @@ namespace ErsatzTV.Application.Channels.Commands
                .MapT(_ => Optional(createChannel.WatermarkId))
                .Map(o => o.ToValidation<BaseError>($"Watermark {createChannel.WatermarkId} does not exist."));
        }
+
+        private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
+            TvContext dbContext,
+            CreateChannel createChannel)
+        {
+            if (createChannel.FallbackFillerId is null)
+            {
+                return Option<int>.None;
+            }
+
+            return await dbContext.FillerPresets
+                .Filter(fp => fp.FillerKind == FillerKind.Fallback)
+                .CountAsync(w => w.Id == createChannel.FallbackFillerId)
+                .Map(Optional)
+                .Filter(c => c > 0)
+                .MapT(_ => Optional(createChannel.FallbackFillerId))
+                .Map(
+                    o => o.ToValidation<BaseError>(
+                        $"Fallback filler {createChannel.FallbackFillerId} does not exist."));
+        }
    }
 }
--- a/ErsatzTV.Application/Channels/Commands/UpdateChannel.cs
+++ b/ErsatzTV.Application/Channels/Commands/UpdateChannel.cs
@@ -14,5 +14,6 @@ namespace ErsatzTV.Application.Channels.Commands
        string Logo,
        string PreferredLanguageCode,
        StreamingMode StreamingMode,
-        int? WatermarkId) : IRequest<Either<BaseError, ChannelViewModel>>;
+        int? WatermarkId,
+        int? FallbackFillerId) : IRequest<Either<BaseError, ChannelViewModel>>;
 }
--- a/ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs
+++ b/ErsatzTV.Application/Channels/Commands/UpdateChannelHandler.cs
@@ -67,6 +67,7 @@ namespace ErsatzTV.Application.Channels.Commands
            
            c.StreamingMode = update.StreamingMode;
            c.WatermarkId = update.WatermarkId;
+            c.FallbackFillerId = update.FallbackFillerId;
            await dbContext.SaveChangesAsync();
            return ProjectToViewModel(c);
        }
--- a/ErsatzTV.Application/Channels/Mapper.cs
+++ b/ErsatzTV.Application/Channels/Mapper.cs
@@ -15,7 +15,9 @@ namespace ErsatzTV.Application.Channels
                GetLogo(channel),
                channel.PreferredLanguageCode,
                channel.StreamingMode,
-                channel.WatermarkId);
+                channel.WatermarkId,
+                channel.FallbackFillerId,
+                channel.Playouts?.Count ?? 0);

        private static string GetLogo(Channel channel) =>
            Optional(channel.Artwork.FirstOrDefault(a => a.ArtworkKind == ArtworkKind.Logo))
--- a/ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs
+++ b/ErsatzTV.Application/Channels/Queries/GetChannelPlaylistHandler.cs
@@ -28,6 +28,10 @@ namespace ErsatzTV.Application.Channels.Queries
            {
                switch (mode.ToLowerInvariant())
                {
+                    case "segmenter":
+                        channel.StreamingMode = StreamingMode.HttpLiveStreamingSegmenter;
+                        result.Add(channel);
+                        break;
                    case "hls-direct":
                        channel.StreamingMode = StreamingMode.HttpLiveStreamingDirect;
                        result.Add(channel);
--- a/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs
+++ b/ErsatzTV.Application/Configuration/Commands/UpdateLibraryRefreshIntervalHandler.cs
@@ -25,7 +25,7 @@ namespace ErsatzTV.Application.Configuration.Commands

        private static Task<Validation<BaseError, Unit>> Validate(UpdateLibraryRefreshInterval request) =>
            Optional(request.LibraryRefreshInterval)
-                .Filter(lri => lri > 0)
+                .Where(lri => lri > 0)
                .Map(_ => Unit.Default)
                .ToValidation<BaseError>("Tuner count must be greater than zero")
                .AsTask();
--- a/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs
+++ b/ErsatzTV.Application/Configuration/Commands/UpdatePlayoutDaysToBuildHandler.cs
@@ -58,7 +58,7 @@ namespace ErsatzTV.Application.Configuration.Commands

        private static Task<Validation<BaseError, Unit>> Validate(UpdatePlayoutDaysToBuild request) =>
            Optional(request.DaysToBuild)
-                .Filter(days => days > 0)
+                .Where(days => days > 0)
                .Map(_ => Unit.Default)
                .ToValidation<BaseError>("Days to build must be greater than zero")
                .AsTask();
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibrariesHandler.cs
@@ -67,7 +67,7 @@ namespace ErsatzTV.Application.Emby.Commands
        {
            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Filter(match => match)
+                .Where(match => match)
                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
                .ToValidation<BaseError>("Emby media source requires an api key");
        }
--- a/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Emby/Commands/SynchronizeEmbyLibraryByIdHandler.cs
@@ -67,7 +67,7 @@ namespace ErsatzTV.Application.Emby.Commands

        private async Task<Unit> Synchronize(RequestParameters parameters)
        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
            {
@@ -142,7 +142,7 @@ namespace ErsatzTV.Application.Emby.Commands
        {
            EmbySecrets secrets = await _embySecretStore.ReadSecrets();
            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Filter(match => match)
+                .Where(match => match)
                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
                .ToValidation<BaseError>("Emby media source requires an api key");
        }
--- a/ErsatzTV.Application/ErsatzTV.Application.csproj
+++ b/ErsatzTV.Application/ErsatzTV.Application.csproj
@@ -1,19 +1,15 @@
 <Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFramework>net5.0</TargetFramework>
+        <TargetFramework>net6.0</TargetFramework>
        <NoWarn>VSTHRD200</NoWarn>
        <DebugType>embedded</DebugType>
    </PropertyGroup>

    <ItemGroup>
-      <PackageReference Include="AsyncFixer" Version="1.5.1">
-        <PrivateAssets>all</PrivateAssets>
-        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      </PackageReference>
      <PackageReference Include="MediatR" Version="9.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
-      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="16.10.56">
+      <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
+      <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.0.64">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      </PackageReference>
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfile.cs
@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
 using LanguageExt;
 using MediatR;

@@ -10,6 +11,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
        int ThreadCount,
        bool Transcode,
        HardwareAccelerationKind HardwareAcceleration,
+        VaapiDriver VaapiDriver,
+        string VaapiDevice,
        int ResolutionId,
        bool NormalizeVideo,
        string VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/CreateFFmpegProfileHandler.cs
@@ -45,6 +45,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                    ThreadCount = threadCount,
                    Transcode = request.Transcode,
                    HardwareAcceleration = request.HardwareAcceleration,
+                    VaapiDriver = request.VaapiDriver,
+                    VaapiDevice = request.VaapiDevice,
                    ResolutionId = resolutionId,
                    NormalizeVideo = request.NormalizeVideo,
                    VideoCodec = request.VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfile.cs
@@ -1,5 +1,6 @@
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;
 using LanguageExt;
 using MediatR;

@@ -11,6 +12,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
        int ThreadCount,
        bool Transcode,
        HardwareAccelerationKind HardwareAcceleration,
+        VaapiDriver VaapiDriver,
+        string VaapiDevice,
        int ResolutionId,
        bool NormalizeVideo,
        string VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegProfileHandler.cs
@@ -36,18 +36,20 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
            p.ThreadCount = update.ThreadCount;
            p.Transcode = update.Transcode;
            p.HardwareAcceleration = update.HardwareAcceleration;
+            p.VaapiDriver = update.VaapiDriver;
+            p.VaapiDevice = update.VaapiDevice;
            p.ResolutionId = update.ResolutionId;
-            p.NormalizeVideo = update.NormalizeVideo;
+            p.NormalizeVideo = update.Transcode && update.NormalizeVideo;
            p.VideoCodec = update.VideoCodec;
            p.VideoBitrate = update.VideoBitrate;
            p.VideoBufferSize = update.VideoBufferSize;
            p.AudioCodec = update.AudioCodec;
            p.AudioBitrate = update.AudioBitrate;
            p.AudioBufferSize = update.AudioBufferSize;
-            p.NormalizeLoudness = update.NormalizeLoudness;
+            p.NormalizeLoudness = update.Transcode && update.NormalizeLoudness;
            p.AudioChannels = update.AudioChannels;
            p.AudioSampleRate = update.AudioSampleRate;
-            p.NormalizeAudio = update.NormalizeAudio;
+            p.NormalizeAudio = update.Transcode && update.NormalizeAudio;
            await dbContext.SaveChangesAsync();
            return new UpdateFFmpegProfileResult(p.Id);
        }
--- a/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Commands/UpdateFFmpegSettingsHandler.cs
@@ -1,13 +1,11 @@
 using System.Diagnostics;
 using System.IO;
-using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
-using ErsatzTV.Core.Interfaces.Runtime;
 using LanguageExt;

 namespace ErsatzTV.Application.FFmpegProfiles.Commands
@@ -16,16 +14,13 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
    {
        private readonly IConfigElementRepository _configElementRepository;
        private readonly ILocalFileSystem _localFileSystem;
-        private readonly IRuntimeInfo _runtimeInfo;

        public UpdateFFmpegSettingsHandler(
            IConfigElementRepository configElementRepository,
-            ILocalFileSystem localFileSystem,
-            IRuntimeInfo runtimeInfo)
+            ILocalFileSystem localFileSystem)
        {
            _configElementRepository = configElementRepository;
            _localFileSystem = localFileSystem;
-            _runtimeInfo = runtimeInfo;
        }

        public Task<Either<BaseError, Unit>> Handle(
@@ -36,8 +31,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                .Bind(v => v.ToEitherAsync());

        private async Task<Validation<BaseError, Unit>> Validate(UpdateFFmpegSettings request) =>
-            (await FFmpegMustExist(request), await FFprobeMustExist(request), ReportsAreNotSupportedOnWindows(request))
-            .Apply((_, _, _) => Unit.Default);
+            (await FFmpegMustExist(request), await FFprobeMustExist(request))
+            .Apply((_, _) => Unit.Default);

        private Task<Validation<BaseError, Unit>> FFmpegMustExist(UpdateFFmpegSettings request) =>
            ValidateToolPath(request.Settings.FFmpegPath, "ffmpeg");
@@ -45,16 +40,6 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
        private Task<Validation<BaseError, Unit>> FFprobeMustExist(UpdateFFmpegSettings request) =>
            ValidateToolPath(request.Settings.FFprobePath, "ffprobe");

-        private Validation<BaseError, Unit> ReportsAreNotSupportedOnWindows(UpdateFFmpegSettings request)
-        {
-            if (request.Settings.SaveReports && _runtimeInfo.IsOSPlatform(OSPlatform.Windows))
-            {
-                return BaseError.New("FFmpeg reports are not supported on Windows");
-            }
-
-            return Unit.Default;
-        }
-
        private async Task<Validation<BaseError, Unit>> ValidateToolPath(string path, string name)
        {
            if (!_localFileSystem.FileExists(path))
@@ -115,6 +100,25 @@ namespace ErsatzTV.Application.FFmpegProfiles.Commands
                await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalWatermarkId);
            }

+            if (request.Settings.GlobalFallbackFillerId is not null)
+            {
+                await _configElementRepository.Upsert(
+                    ConfigElementKey.FFmpegGlobalFallbackFillerId,
+                    request.Settings.GlobalFallbackFillerId.Value);
+            }
+            else
+            {
+                await _configElementRepository.Delete(ConfigElementKey.FFmpegGlobalFallbackFillerId);
+            }
+
+            await _configElementRepository.Upsert(
+                ConfigElementKey.FFmpegSegmenterTimeout,
+                request.Settings.HlsSegmenterIdleTimeout);
+
+            await _configElementRepository.Upsert(
+                ConfigElementKey.FFmpegWorkAheadSegmenters,
+                request.Settings.WorkAheadSegmenterLimit);
+
            return Unit.Default;
        }
    }
--- a/ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/FFmpegProfileViewModel.cs
@@ -1,5 +1,6 @@
 using ErsatzTV.Application.Resolutions;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.FFmpeg;

 namespace ErsatzTV.Application.FFmpegProfiles
 {
@@ -9,6 +10,8 @@ namespace ErsatzTV.Application.FFmpegProfiles
        int ThreadCount,
        bool Transcode,
        HardwareAccelerationKind HardwareAcceleration,
+        VaapiDriver VaapiDriver,
+        string VaapiDevice,
        ResolutionViewModel Resolution,
        bool NormalizeVideo,
        string VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/FFmpegSettingsViewModel.cs
@@ -8,5 +8,8 @@
        public string PreferredLanguageCode { get; set; }
        public bool SaveReports { get; set; }
        public int? GlobalWatermarkId { get; set; }
+        public int? GlobalFallbackFillerId { get; set; }
+        public int HlsSegmenterIdleTimeout { get; set; }
+        public int WorkAheadSegmenterLimit { get; set; }
    }
 }
--- a/ErsatzTV.Application/FFmpegProfiles/Mapper.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Mapper.cs
@@ -12,6 +12,8 @@ namespace ErsatzTV.Application.FFmpegProfiles
                profile.ThreadCount,
                profile.Transcode,
                profile.HardwareAcceleration,
+                profile.VaapiDriver,
+                profile.VaapiDevice,
                Project(profile.Resolution),
                profile.NormalizeVideo,
                profile.VideoCodec,
--- a/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs
+++ b/ErsatzTV.Application/FFmpegProfiles/Queries/GetFFmpegSettingsHandler.cs
@@ -28,6 +28,12 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                await _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPreferredLanguageCode);
            Option<int> watermark =
                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalWatermarkId);
+            Option<int> fallbackFiller =
+                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegGlobalFallbackFillerId);
+            Option<int> hlsSegmenterIdleTimeout =
+                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegSegmenterTimeout);
+            Option<int> workAheadSegmenterLimit =
+                await _configElementRepository.GetValue<int>(ConfigElementKey.FFmpegWorkAheadSegmenters);

            var result = new FFmpegSettingsViewModel
            {
@@ -36,6 +42,8 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                DefaultFFmpegProfileId = await defaultFFmpegProfileId.IfNoneAsync(0),
                SaveReports = await saveReports.IfNoneAsync(false),
                PreferredLanguageCode = await preferredLanguageCode.IfNoneAsync("eng"),
+                HlsSegmenterIdleTimeout = await hlsSegmenterIdleTimeout.IfNoneAsync(60),
+                WorkAheadSegmenterLimit = await workAheadSegmenterLimit.IfNoneAsync(1),
            };

            foreach (int watermarkId in watermark)
@@ -43,6 +51,11 @@ namespace ErsatzTV.Application.FFmpegProfiles.Queries
                result.GlobalWatermarkId = watermarkId;
            }

+            foreach (int fallbackFillerId in fallbackFiller)
+            {
+                result.GlobalFallbackFillerId = fallbackFillerId;
+            }
+
            return result;
        }
    }
--- a/ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs
+++ b/ErsatzTV.Application/Filler/Commands/CreateFillerPreset.cs
@@ -0,0 +1,24 @@
+using System;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public record CreateFillerPreset(
+        string Name,
+        FillerKind FillerKind,
+        FillerMode FillerMode,
+        TimeSpan? Duration,
+        int? Count,
+        int? PadToNearestMinute,
+        ProgramScheduleItemCollectionType CollectionType,
+        int? CollectionId,
+        int? MediaItemId,
+        int? MultiCollectionId,
+        int? SmartCollectionId
+    ) : IRequest<Either<BaseError, Unit>>;
+}
--- a/ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs
+++ b/ErsatzTV.Application/Filler/Commands/CreateFillerPresetHandler.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public class CreateFillerPresetHandler : IRequestHandler<CreateFillerPreset, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public CreateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
+        {
+            _dbContextFactory = dbContextFactory;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(CreateFillerPreset request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+                var fillerPreset = new FillerPreset
+                {
+                    Name = request.Name,
+                    FillerKind = request.FillerKind,
+                    FillerMode = request.FillerMode,
+                    Duration = request.Duration,
+                    Count = request.Count,
+                    PadToNearestMinute = request.PadToNearestMinute,
+                    CollectionType = request.CollectionType,
+                    CollectionId = request.CollectionId,
+                    MediaItemId = request.MediaItemId,
+                    MultiCollectionId = request.MultiCollectionId,
+                    SmartCollectionId = request.SmartCollectionId
+                };
+
+                await dbContext.FillerPresets.AddAsync(fillerPreset, cancellationToken);
+                await dbContext.SaveChangesAsync(cancellationToken);
+
+                return Unit.Default;
+            }
+            catch (Exception ex)
+            {
+                return BaseError.New(ex.Message);
+            }
+        }
+    }
+}
--- a/ErsatzTV.Application/Filler/Commands/DeleteFillerPreset.cs
+++ b/ErsatzTV.Application/Filler/Commands/DeleteFillerPreset.cs
@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public record DeleteFillerPreset(int FillerPresetId) : IRequest<Either<BaseError, LanguageExt.Unit>>;
+}
--- a/ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs
+++ b/ErsatzTV.Application/Filler/Commands/DeleteFillerPresetHandler.cs
@@ -0,0 +1,43 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public class DeleteFillerPresetHandler : IRequestHandler<DeleteFillerPreset, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public DeleteFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DeleteFillerPreset request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
+            return await validation.Apply(ps => DoDeletion(dbContext, ps));
+        }
+
+        private static Task<Unit> DoDeletion(TvContext dbContext, FillerPreset fillerPreset)
+        {
+            dbContext.FillerPresets.Remove(fillerPreset);
+            return dbContext.SaveChangesAsync().ToUnit();
+        }
+
+        private Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
+            TvContext dbContext,
+            DeleteFillerPreset request) =>
+            dbContext.FillerPresets
+                .SelectOneAsync(fp => fp.Id, ps => ps.Id == request.FillerPresetId)
+                .Map(o => o.ToValidation<BaseError>($"FillerPreset {request.FillerPresetId} does not exist."));
+    }
+}
--- a/ErsatzTV.Application/Filler/Commands/UpdateFillerPreset.cs
+++ b/ErsatzTV.Application/Filler/Commands/UpdateFillerPreset.cs
@@ -0,0 +1,25 @@
+using System;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public record UpdateFillerPreset(
+        int Id,
+        string Name,
+        FillerKind FillerKind,
+        FillerMode FillerMode,
+        TimeSpan? Duration,
+        int? Count,
+        int? PadToNearestMinute,
+        ProgramScheduleItemCollectionType CollectionType,
+        int? CollectionId,
+        int? MediaItemId,
+        int? MultiCollectionId,
+        int? SmartCollectionId
+    ) : IRequest<Either<BaseError, Unit>>;
+}
--- a/ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs
+++ b/ErsatzTV.Application/Filler/Commands/UpdateFillerPresetHandler.cs
@@ -0,0 +1,60 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.Filler.Commands
+{
+    public class UpdateFillerPresetHandler : IRequestHandler<UpdateFillerPreset, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public UpdateFillerPresetHandler(IDbContextFactory<TvContext> dbContextFactory)
+        {
+            _dbContextFactory = dbContextFactory;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(UpdateFillerPreset request, CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+            Validation<BaseError, FillerPreset> validation = await FillerPresetMustExist(dbContext, request);
+            return await validation.Apply(ps => ApplyUpdateRequest(dbContext, ps, request));
+        }
+
+        private async Task<Unit> ApplyUpdateRequest(
+            TvContext dbContext,
+            FillerPreset existing,
+            UpdateFillerPreset request)
+        {
+            existing.Name = request.Name;
+            existing.FillerKind = request.FillerKind;
+            existing.FillerMode = request.FillerMode;
+            existing.Duration = request.Duration;
+            existing.Count = request.Count;
+            existing.PadToNearestMinute = request.PadToNearestMinute;
+            existing.CollectionType = request.CollectionType;
+            existing.CollectionId = request.CollectionId;
+            existing.MediaItemId = request.MediaItemId;
+            existing.MultiCollectionId = request.MultiCollectionId;
+            existing.SmartCollectionId = request.SmartCollectionId;
+
+            await dbContext.SaveChangesAsync();
+
+            return Unit.Default;
+        }
+
+        private static Task<Validation<BaseError, FillerPreset>> FillerPresetMustExist(
+            TvContext dbContext,
+            UpdateFillerPreset request) =>
+            dbContext.FillerPresets
+                .SelectOneAsync(ps => ps.Id, ps => ps.Id == request.Id)
+                .Map(o => o.ToValidation<BaseError>("FillerPreset does not exist"));
+    }
+}
--- a/ErsatzTV.Application/Filler/FillerPresetViewModel.cs
+++ b/ErsatzTV.Application/Filler/FillerPresetViewModel.cs
@@ -0,0 +1,20 @@
+using System;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Application.Filler
+{
+    public record FillerPresetViewModel(
+        int Id,
+        string Name,
+        FillerKind FillerKind,
+        FillerMode FillerMode,
+        TimeSpan? Duration,
+        int? Count,
+        int? PadToNearestMinute,
+        ProgramScheduleItemCollectionType CollectionType,
+        int? CollectionId,
+        int? MediaItemId,
+        int? MultiCollectionId,
+        int? SmartCollectionId);
+}
--- a/ErsatzTV.Application/Filler/Mapper.cs
+++ b/ErsatzTV.Application/Filler/Mapper.cs
@@ -0,0 +1,22 @@
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Application.Filler
+{
+    internal static class Mapper
+    {
+        internal static FillerPresetViewModel ProjectToViewModel(FillerPreset fillerPreset) =>
+            new(
+                fillerPreset.Id,
+                fillerPreset.Name,
+                fillerPreset.FillerKind,
+                fillerPreset.FillerMode,
+                fillerPreset.Duration,
+                fillerPreset.Count,
+                fillerPreset.PadToNearestMinute,
+                fillerPreset.CollectionType,
+                fillerPreset.CollectionId,
+                fillerPreset.MediaItemId,
+                fillerPreset.MultiCollectionId,
+                fillerPreset.SmartCollectionId);
+    }
+}
--- a/ErsatzTV.Application/Filler/PagedFillerPresetsViewModel.cs
+++ b/ErsatzTV.Application/Filler/PagedFillerPresetsViewModel.cs
@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.Filler
+{
+    public record PagedFillerPresetsViewModel(int TotalCount, List<FillerPresetViewModel> Page);
+}
--- a/ErsatzTV.Application/Filler/Queries/GetAllFillerPresets.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetAllFillerPresets.cs
@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+using MediatR;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public record GetAllFillerPresets : IRequest<List<FillerPresetViewModel>>;
+}
--- a/ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsHandler.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsHandler.cs
@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Infrastructure.Data;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using LanguageExt;
+using static ErsatzTV.Application.Filler.Mapper;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public class GetAllFillerPresetsHandler : IRequestHandler<GetAllFillerPresets, List<FillerPresetViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetAllFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<List<FillerPresetViewModel>> Handle(
+            GetAllFillerPresets request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.FillerPresets.ToListAsync(cancellationToken)
+                .Map(presets => presets.Map(ProjectToViewModel).ToList());
+        }
+    }
+}
--- a/ErsatzTV.Application/Filler/Queries/GetFillerPresetById.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetFillerPresetById.cs
@@ -0,0 +1,7 @@
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public record GetFillerPresetById(int Id) : IRequest<Option<FillerPresetViewModel>>;
+}
--- a/ErsatzTV.Application/Filler/Queries/GetFillerPresetByIdHandler.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetFillerPresetByIdHandler.cs
@@ -0,0 +1,29 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Filler.Mapper;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public class GetFillerPresetByIdHandler : IRequestHandler<GetFillerPresetById, Option<FillerPresetViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetFillerPresetByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Option<FillerPresetViewModel>> Handle(
+            GetFillerPresetById request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            return await dbContext.FillerPresets
+                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
+                .MapT(ProjectToViewModel);
+        }
+    }
+}
--- a/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresets.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresets.cs
@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public record GetPagedFillerPresets(int PageNum, int PageSize) : IRequest<PagedFillerPresetsViewModel>;
+}
--- a/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs
+++ b/ErsatzTV.Application/Filler/Queries/GetPagedFillerPresetsHandler.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Infrastructure.Data;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using LanguageExt;
+using static ErsatzTV.Application.Filler.Mapper;
+
+namespace ErsatzTV.Application.Filler.Queries
+{
+    public class GetPagedFillerPresetsHandler : IRequestHandler<GetPagedFillerPresets, PagedFillerPresetsViewModel>
+    {
+        private readonly IDbConnection _dbConnection;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetPagedFillerPresetsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+        }
+
+        public async Task<PagedFillerPresetsViewModel> Handle(
+            GetPagedFillerPresets request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM FillerPreset");
+
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            List<FillerPresetViewModel> page = await dbContext.FillerPresets.FromSqlRaw(
+                    @"SELECT * FROM FillerPreset
+                    ORDER BY Name
+                    COLLATE NOCASE
+                    LIMIT {0} OFFSET {1}",
+                    request.PageSize,
+                    request.PageNum * request.PageSize)
+                .ToListAsync(cancellationToken)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new PagedFillerPresetsViewModel(count, page);
+        }
+    }
+}
--- a/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCountHandler.cs
+++ b/ErsatzTV.Application/HDHR/Commands/UpdateHDHRTunerCountHandler.cs
@@ -24,7 +24,7 @@ namespace ErsatzTV.Application.HDHR.Commands

        private static Task<Validation<BaseError, Unit>> Validate(UpdateHDHRTunerCount request) =>
            Optional(request.TunerCount)
-                .Filter(tc => tc > 0)
+                .Where(tc => tc > 0)
                .Map(_ => Unit.Default)
                .ToValidation<BaseError>("Tuner count must be greater than zero")
                .AsTask();
--- a/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs
+++ b/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResults.cs
@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Health;
+using MediatR;
+
+namespace ErsatzTV.Application.Health.Queries
+{
+    public record GetAllHealthCheckResults : IRequest<List<HealthCheckResult>>;
+}
--- a/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs
+++ b/ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsHandler.cs
@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core.Health;
+using MediatR;
+
+namespace ErsatzTV.Application.Health.Queries
+{
+    public class GetAllHealthCheckResultsHandler : IRequestHandler<GetAllHealthCheckResults, List<HealthCheckResult>>
+    {
+        private readonly IHealthCheckService _healthCheckService;
+
+        public GetAllHealthCheckResultsHandler(IHealthCheckService healthCheckService) =>
+            _healthCheckService = healthCheckService;
+
+        public async Task<List<HealthCheckResult>> Handle(
+            GetAllHealthCheckResults request,
+            CancellationToken cancellationToken)
+        {
+            List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks();
+            return results.Filter(r => r.Status != HealthCheckStatus.NotApplicable).ToList();
+        }
+    }
+}
--- a/ErsatzTV.Application/IFFmpegWorkerRequest.cs
+++ b/ErsatzTV.Application/IFFmpegWorkerRequest.cs
@@ -0,0 +1,6 @@
+namespace ErsatzTV.Application
+{
+    public interface IFFmpegWorkerRequest
+    {
+    }
+}
--- a/ErsatzTV.Application/Images/Commands/SaveArtworkToDisk.cs
+++ b/ErsatzTV.Application/Images/Commands/SaveArtworkToDisk.cs
@@ -1,4 +1,5 @@
-using ErsatzTV.Core;
+using System.IO;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using LanguageExt;
 using MediatR;
@@ -6,5 +7,5 @@ using MediatR;
 namespace ErsatzTV.Application.Images.Commands
 {
    // ReSharper disable once SuggestBaseTypeForParameter
-    public record SaveArtworkToDisk(byte[] Buffer, ArtworkKind ArtworkKind) : IRequest<Either<BaseError, string>>;
+    public record SaveArtworkToDisk(Stream Stream, ArtworkKind ArtworkKind) : IRequest<Either<BaseError, string>>;
 }
--- a/ErsatzTV.Application/Images/Commands/SaveArtworkToDiskHandler.cs
+++ b/ErsatzTV.Application/Images/Commands/SaveArtworkToDiskHandler.cs
@@ -14,6 +14,6 @@ namespace ErsatzTV.Application.Images.Commands
        public SaveArtworkToDiskHandler(IImageCache imageCache) => _imageCache = imageCache;

        public Task<Either<BaseError, string>> Handle(SaveArtworkToDisk request, CancellationToken cancellationToken) =>
-            _imageCache.SaveArtworkToCache(request.Buffer, request.ArtworkKind);
+            _imageCache.SaveArtworkToCache(request.Stream, request.ArtworkKind);
    }
 }
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinAdminUserIdHandler.cs
@@ -97,7 +97,7 @@ namespace ErsatzTV.Application.Jellyfin.Commands
        {
            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Filter(match => match)
+                .Where(match => match)
                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
                .ToValidation<BaseError>("Jellyfin media source requires an api key");
        }
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibrariesHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibrariesHandler.cs
@@ -69,7 +69,7 @@ namespace ErsatzTV.Application.Jellyfin.Commands
        {
            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Filter(match => match)
+                .Where(match => match)
                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
                .ToValidation<BaseError>("Jellyfin media source requires an api key");
        }
--- a/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs
@@ -67,7 +67,7 @@ namespace ErsatzTV.Application.Jellyfin.Commands

        private async Task<Unit> Synchronize(RequestParameters parameters)
        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
            {
@@ -142,7 +142,7 @@ namespace ErsatzTV.Application.Jellyfin.Commands
        {
            JellyfinSecrets secrets = await _jellyfinSecretStore.ReadSecrets();
            return Optional(secrets.Address == connectionParameters.ActiveConnection.Address)
-                .Filter(match => match)
+                .Where(match => match)
                .Map(_ => connectionParameters with { ApiKey = secrets.ApiKey })
                .ToValidation<BaseError>("Jellyfin media source requires an api key");
        }
--- a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryHandler.cs
@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
@@ -37,7 +36,7 @@ namespace ErsatzTV.Application.Libraries.Commands
            CreateLocalLibrary request,
            CancellationToken cancellationToken)
        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
            Validation<BaseError, LocalLibrary> validation = await Validate(dbContext, request);
            return await validation.Apply(localLibrary => PersistLocalLibrary(dbContext, localLibrary));
        }
--- a/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/CreateLocalLibraryPathHandler.cs
@@ -46,7 +46,7 @@ namespace ErsatzTV.Application.Libraries.Commands
                .Map(list => list.Map(c => c.Path).ToList());

            return Optional(request.Path)
-                .Filter(folder => allPaths.ForAll(f => !AreSubPaths(f, folder)))
+                .Where(folder => allPaths.ForAll(f => !AreSubPaths(f, folder)))
                .ToValidation<BaseError>("Path must not belong to another library path");
        }

--- a/ErsatzTV.Application/Libraries/Commands/LocalLibraryHandlerBase.cs
+++ b/ErsatzTV.Application/Libraries/Commands/LocalLibraryHandlerBase.cs
@@ -33,7 +33,7 @@ namespace ErsatzTV.Application.Libraries.Commands
                .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)
+                .Where(length => length == 0)
                .Map(_ => localLibrary)
                .ToValidation<BaseError>("Path must not belong to another library path");
        }
--- a/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -8,6 +9,7 @@ using ErsatzTV.Application.MediaSources.Commands;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Search;
 using ErsatzTV.Infrastructure.Data;
 using ErsatzTV.Infrastructure.Extensions;
 using LanguageExt;
@@ -22,15 +24,18 @@ namespace ErsatzTV.Application.Libraries.Commands
    {
        private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
        private readonly IEntityLocker _entityLocker;
+        private readonly ISearchIndex _searchIndex;
        private readonly IDbContextFactory<TvContext> _dbContextFactory;

        public UpdateLocalLibraryHandler(
            ChannelWriter<IBackgroundServiceRequest> workerChannel,
            IEntityLocker entityLocker,
+            ISearchIndex searchIndex,
            IDbContextFactory<TvContext> dbContextFactory)
        {
            _workerChannel = workerChannel;
            _entityLocker = entityLocker;
+            _searchIndex = searchIndex;
            _dbContextFactory = dbContextFactory;
        }

@@ -38,7 +43,7 @@ namespace ErsatzTV.Application.Libraries.Commands
            UpdateLocalLibrary request,
            CancellationToken cancellationToken)
        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
            return await validation.Apply(parameters => UpdateLocalLibrary(dbContext, parameters));
        }
@@ -48,7 +53,6 @@ namespace ErsatzTV.Application.Libraries.Commands
            (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();
@@ -56,12 +60,23 @@ namespace ErsatzTV.Application.Libraries.Commands
                .Filter(ep => incoming.Paths.All(p => NormalizePath(p.Path) != NormalizePath(ep.Path)))
                .ToList();

+            var toRemoveIds = toRemove.Map(lp => lp.Id).ToList();
+
+            List<int> itemsToRemove = await dbContext.MediaItems
+                .Filter(mi => toRemoveIds.Contains(mi.LibraryPathId))
+                .Map(mi => mi.Id)
+                .ToListAsync();
+            
            existing.Paths.RemoveAll(toRemove.Contains);
            existing.Paths.AddRange(toAdd);

-            await dbContext.SaveChangesAsync();
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                await _searchIndex.RemoveItems(itemsToRemove);
+                _searchIndex.Commit();
+            }

-            if (toAdd.Count > 0 || toRemove.Count > 0 && _entityLocker.LockLibrary(existing.Id))
+            if ((toAdd.Count > 0 || toRemove.Count > 0) && _entityLocker.LockLibrary(existing.Id))
            {
                await _workerChannel.WriteAsync(new ForceScanLocalLibrary(existing.Id));
            }
--- a/ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/CollectionCardResultsViewModel.cs
@@ -9,7 +9,9 @@ namespace ErsatzTV.Application.MediaCards
        List<TelevisionSeasonCardViewModel> SeasonCards,
        List<TelevisionEpisodeCardViewModel> EpisodeCards,
        List<ArtistCardViewModel> ArtistCards,
-        List<MusicVideoCardViewModel> MusicVideoCards)
+        List<MusicVideoCardViewModel> MusicVideoCards,
+        List<OtherVideoCardViewModel> OtherVideoCards,
+        List<SongCardViewModel> SongCards)
    {
        public bool UseCustomPlaybackOrder { get; set; }
    }
--- a/ErsatzTV.Application/MediaCards/Mapper.cs
+++ b/ErsatzTV.Application/MediaCards/Mapper.cs
@@ -1,5 +1,5 @@
-using System;
-using System.Linq;
+using System.Linq;
+using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Emby;
 using ErsatzTV.Core.Jellyfin;
@@ -20,7 +20,7 @@ namespace ErsatzTV.Application.MediaCards
                showMetadata.Year?.ToString(),
                showMetadata.SortTitle,
                GetPoster(showMetadata, maybeJellyfin, maybeEmby));
-
+        
        internal static TelevisionSeasonCardViewModel ProjectToViewModel(
            Season season,
            Option<JellyfinMediaSource> maybeJellyfin,
@@ -36,6 +36,26 @@ namespace ErsatzTV.Application.MediaCards
                    .IfNone(string.Empty),
                season.SeasonNumber == 0 ? "S" : season.SeasonNumber.ToString());

+        internal static TelevisionSeasonCardViewModel ProjectToViewModel(
+            SeasonMetadata seasonMetadata,
+            Option<JellyfinMediaSource> maybeJellyfin,
+            Option<EmbyMediaSource> maybeEmby)
+        {
+            string showTitle = seasonMetadata.Season.Show.ShowMetadata.HeadOrNone().Match(
+                m => m.Title ?? string.Empty,
+                () => string.Empty);
+
+            return new TelevisionSeasonCardViewModel(
+                showTitle,
+                seasonMetadata.SeasonId,
+                seasonMetadata.Season.SeasonNumber,
+                showTitle,
+                GetSeasonName(seasonMetadata.Season.SeasonNumber),
+                $"{showTitle}_{seasonMetadata.Season.SeasonNumber:0000}",
+                GetPoster(seasonMetadata, maybeJellyfin, maybeEmby),
+                seasonMetadata.Season.SeasonNumber == 0 ? "S" : seasonMetadata.Season.SeasonNumber.ToString());
+        }
+
        internal static TelevisionEpisodeCardViewModel ProjectToViewModel(
            EpisodeMetadata episodeMetadata,
            Option<JellyfinMediaSource> maybeJellyfin,
@@ -43,7 +63,7 @@ namespace ErsatzTV.Application.MediaCards
            bool isSearchResult) =>
            new(
                episodeMetadata.EpisodeId,
-                episodeMetadata.ReleaseDate ?? DateTime.MinValue,
+                episodeMetadata.ReleaseDate ?? SystemTime.MinValueUtc,
                episodeMetadata.Episode.Season.Show.ShowMetadata.HeadOrNone().Match(
                    m => m.Title ?? string.Empty,
                    () => string.Empty),
@@ -80,8 +100,26 @@ namespace ErsatzTV.Application.MediaCards
                musicVideoMetadata.MusicVideo.Artist.ArtistMetadata.Head().Title,
                musicVideoMetadata.SortTitle,
                musicVideoMetadata.Plot,
+                musicVideoMetadata.Album,
                GetThumbnail(musicVideoMetadata, None, None));

+        internal static OtherVideoCardViewModel ProjectToViewModel(OtherVideoMetadata otherVideoMetadata) =>
+            new(
+                otherVideoMetadata.OtherVideoId,
+                otherVideoMetadata.Title,
+                otherVideoMetadata.OriginalTitle,
+                otherVideoMetadata.SortTitle);
+
+        internal static SongCardViewModel ProjectToViewModel(SongMetadata songMetadata)
+        {
+            string album = string.IsNullOrWhiteSpace(songMetadata.Album) ? "" : $" - {songMetadata.Album}";
+            return new SongCardViewModel(
+                songMetadata.SongId,
+                songMetadata.Title,
+                songMetadata.Artist + album,
+                songMetadata.SortTitle);
+        }
+
        internal static ArtistCardViewModel ProjectToViewModel(ArtistMetadata artistMetadata) =>
            new(
                artistMetadata.ArtistId,
@@ -112,6 +150,10 @@ namespace ErsatzTV.Application.MediaCards
                    .ToList(),
                collection.MediaItems.OfType<Artist>().Map(a => ProjectToViewModel(a.ArtistMetadata.Head())).ToList(),
                collection.MediaItems.OfType<MusicVideo>().Map(mv => ProjectToViewModel(mv.MusicVideoMetadata.Head()))
+                    .ToList(),
+                collection.MediaItems.OfType<OtherVideo>().Map(ov => ProjectToViewModel(ov.OtherVideoMetadata.Head()))
+                    .ToList(),
+                collection.MediaItems.OfType<Song>().Map(s => ProjectToViewModel(s.SongMetadata.Head()))
                    .ToList()) { UseCustomPlaybackOrder = collection.UseCustomPlaybackOrder };

        internal static ActorCardViewModel ProjectToViewModel(
--- a/ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/MusicVideoCardViewModel.cs
@@ -7,6 +7,7 @@
        string Subtitle,
        string SortTitle,
        string Plot,
+        string Album,
        string Poster) : MediaCardViewModel(
        MusicVideoId,
        Title,
--- a/ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/OtherVideoCardResultsViewModel.cs
@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record OtherVideoCardResultsViewModel(
+        int Count,
+        List<OtherVideoCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
+}
--- a/ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/OtherVideoCardViewModel.cs
@@ -0,0 +1,17 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record OtherVideoCardViewModel
+    (
+        int OtherVideoId,
+        string Title,
+        string Subtitle,
+        string SortTitle) : MediaCardViewModel(
+        OtherVideoId,
+        Title,
+        Subtitle,
+        SortTitle,
+        null)
+    {
+        public int CustomIndex { get; set; }
+    }
+}
--- a/ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetCollectionCardsHandler.cs
@@ -30,7 +30,7 @@ namespace ErsatzTV.Application.MediaCards.Queries
            GetCollectionCards request,
            CancellationToken cancellationToken)
        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);

            Option<JellyfinMediaSource> maybeJellyfin = await _mediaSourceRepository.GetAllJellyfin()
                .Map(list => list.HeadOrNone());
@@ -80,6 +80,12 @@ namespace ErsatzTV.Application.MediaCards.Queries
                .Include(c => c.MediaItems)
                .ThenInclude(i => (i as Episode).Season)
                .ThenInclude(s => s.SeasonMetadata)
+                .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+                .ThenInclude(ovm => ovm.Artwork)
+                .Include(c => c.MediaItems)
+                .ThenInclude(i => (i as Song).SongMetadata)
+                .ThenInclude(ovm => ovm.Artwork)
                .SelectOneAsync(c => c.Id, c => c.Id == request.Id)
                .Map(c => c.ToEither(BaseError.New("Unable to load collection")))
                .MapT(c => ProjectToViewModel(c, maybeJellyfin, maybeEmby));
--- a/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs
+++ b/ErsatzTV.Application/MediaCards/Queries/GetTelevisionSeasonCardsHandler.cs
@@ -7,6 +7,7 @@ using ErsatzTV.Core.Interfaces.Repositories;
 using LanguageExt;
 using MediatR;
 using static ErsatzTV.Application.MediaCards.Mapper;
+using static LanguageExt.Prelude;

 namespace ErsatzTV.Application.MediaCards.Queries
 {
@@ -41,7 +42,7 @@ namespace ErsatzTV.Application.MediaCards.Queries
                .GetPagedSeasons(request.TelevisionShowId, request.PageNumber, request.PageSize)
                .Map(list => list.Map(s => ProjectToViewModel(s, maybeJellyfin, maybeEmby)).ToList());

-            return new TelevisionSeasonCardResultsViewModel(count, results);
+            return new TelevisionSeasonCardResultsViewModel(count, results, None);
        }
    }
 }
--- a/ErsatzTV.Application/MediaCards/SongCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/SongCardResultsViewModel.cs
@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCards
+{
+    public record SongCardResultsViewModel(
+        int Count,
+        List<SongCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
+}
--- a/ErsatzTV.Application/MediaCards/SongCardViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/SongCardViewModel.cs
@@ -0,0 +1,17 @@
+namespace ErsatzTV.Application.MediaCards
+{
+    public record SongCardViewModel
+    (
+        int SongId,
+        string Title,
+        string Subtitle,
+        string SortTitle) : MediaCardViewModel(
+        SongId,
+        Title,
+        Subtitle,
+        SortTitle,
+        null)
+    {
+        public int CustomIndex { get; set; }
+    }
+}
--- a/ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs
+++ b/ErsatzTV.Application/MediaCards/TelevisionSeasonCardResultsViewModel.cs
@@ -1,6 +1,11 @@
 using System.Collections.Generic;
+using ErsatzTV.Core.Search;
+using LanguageExt;

 namespace ErsatzTV.Application.MediaCards
 {
-    public record TelevisionSeasonCardResultsViewModel(int Count, List<TelevisionSeasonCardViewModel> Cards);
+    public record TelevisionSeasonCardResultsViewModel(
+        int Count,
+        List<TelevisionSeasonCardViewModel> Cards,
+        Option<SearchPageMap> PageMap);
 }
--- a/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollection.cs
@@ -9,7 +9,10 @@ namespace ErsatzTV.Application.MediaCollections.Commands
        int CollectionId,
        List<int> MovieIds,
        List<int> ShowIds,
+        List<int> SeasonIds,
        List<int> EpisodeIds,
        List<int> ArtistIds,
-        List<int> MusicVideoIds) : MediatR.IRequest<Either<BaseError, Unit>>;
+        List<int> MusicVideoIds,
+        List<int> OtherVideoIds,
+        List<int> SongIds) : MediatR.IRequest<Either<BaseError, Unit>>;
 }
--- a/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddItemsToCollectionHandler.cs
@@ -52,9 +52,12 @@ namespace ErsatzTV.Application.MediaCollections.Commands
        {
            var allItems = request.MovieIds
                .Append(request.ShowIds)
+                .Append(request.SeasonIds)
                .Append(request.EpisodeIds)
                .Append(request.ArtistIds)
                .Append(request.MusicVideoIds)
+                .Append(request.OtherVideoIds)
+                .Append(request.SongIds)
                .ToList();

            var toAddIds = allItems.Where(item => collection.MediaItems.All(mi => mi.Id != item)).ToList();
@@ -77,12 +80,15 @@ namespace ErsatzTV.Application.MediaCollections.Commands
            return Unit.Default;
        }

-        private async Task<Validation<BaseError, Collection>> Validate(TvContext dbContext, AddItemsToCollection request) =>
+        private async Task<Validation<BaseError, Collection>> Validate(
+            TvContext dbContext,
+            AddItemsToCollection request) =>
            (await CollectionMustExist(dbContext, request),
                await ValidateMovies(request),
                await ValidateShows(request),
+                await ValidateSeasons(request),
                await ValidateEpisodes(request))
-            .Apply((collection, _, _, _) => collection);
+            .Apply((collection, _, _, _, _) => collection);

        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
            TvContext dbContext,
@@ -106,6 +112,13 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                .MapT(_ => Unit.Default)
                .Map(v => v.ToValidation<BaseError>("Show does not exist"));

+        private Task<Validation<BaseError, Unit>> ValidateSeasons(AddItemsToCollection request) =>
+            _televisionRepository.AllSeasonsExist(request.SeasonIds)
+                .Map(Optional)
+                .Filter(v => v == true)
+                .MapT(_ => Unit.Default)
+                .Map(v => v.ToValidation<BaseError>("Season does not exist"));
+
        private Task<Validation<BaseError, Unit>> ValidateEpisodes(AddItemsToCollection request) =>
            _televisionRepository.AllEpisodesExist(request.EpisodeIds)
                .Map(Optional)
--- a/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollection.cs
@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddOtherVideoToCollection
+        (int CollectionId, int OtherVideoId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddOtherVideoToCollectionHandler.cs
@@ -0,0 +1,80 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class AddOtherVideoToCollectionHandler :
+        MediatR.IRequestHandler<AddOtherVideoToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public AddOtherVideoToCollectionHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _dbContextFactory = dbContextFactory;
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            AddOtherVideoToCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+            return await validation.Apply(parameters => ApplyAddOtherVideoRequest(dbContext, parameters));
+        }
+
+        private async Task<Unit> ApplyAddOtherVideoRequest(TvContext dbContext, Parameters parameters)
+        {
+            parameters.Collection.MediaItems.Add(parameters.OtherVideo);
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private static async Task<Validation<BaseError, Parameters>> Validate(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            (await CollectionMustExist(dbContext, request), await ValidateOtherVideo(dbContext, request))
+            .Apply((collection, episode) => new Parameters(collection, episode));
+
+        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            dbContext.Collections
+                .Include(c => c.MediaItems)
+                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+        private static Task<Validation<BaseError, OtherVideo>> ValidateOtherVideo(
+            TvContext dbContext,
+            AddOtherVideoToCollection request) =>
+            dbContext.OtherVideos
+                .SelectOneAsync(m => m.Id, e => e.Id == request.OtherVideoId)
+                .Map(o => o.ToValidation<BaseError>("OtherVideo does not exist"));
+
+        private record Parameters(Collection Collection, OtherVideo OtherVideo);
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollection.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollection.cs
@@ -0,0 +1,8 @@
+using ErsatzTV.Core;
+using LanguageExt;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddSongToCollection
+        (int CollectionId, int SongId) : MediatR.IRequest<Either<BaseError, Unit>>;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddSongToCollectionHandler.cs
@@ -0,0 +1,80 @@
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ErsatzTV.Application.Playouts.Commands;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class AddSongToCollectionHandler :
+        MediatR.IRequestHandler<AddSongToCollection, Either<BaseError, Unit>>
+    {
+        private readonly ChannelWriter<IBackgroundServiceRequest> _channel;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IMediaCollectionRepository _mediaCollectionRepository;
+
+        public AddSongToCollectionHandler(
+            IDbContextFactory<TvContext> dbContextFactory,
+            IMediaCollectionRepository mediaCollectionRepository,
+            ChannelWriter<IBackgroundServiceRequest> channel)
+        {
+            _dbContextFactory = dbContextFactory;
+            _mediaCollectionRepository = mediaCollectionRepository;
+            _channel = channel;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            AddSongToCollection request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+            Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+            return await validation.Apply(parameters => ApplyAddSongRequest(dbContext, parameters));
+        }
+
+        private async Task<Unit> ApplyAddSongRequest(TvContext dbContext, Parameters parameters)
+        {
+            parameters.Collection.MediaItems.Add(parameters.Song);
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                // rebuild all playouts that use this collection
+                foreach (int playoutId in await _mediaCollectionRepository
+                    .PlayoutIdsUsingCollection(parameters.Collection.Id))
+                {
+                    await _channel.WriteAsync(new BuildPlayout(playoutId, true));
+                }
+            }
+
+            return Unit.Default;
+        }
+
+        private static async Task<Validation<BaseError, Parameters>> Validate(
+            TvContext dbContext,
+            AddSongToCollection request) =>
+            (await CollectionMustExist(dbContext, request), await ValidateSong(dbContext, request))
+            .Apply((collection, episode) => new Parameters(collection, episode));
+
+        private static Task<Validation<BaseError, Collection>> CollectionMustExist(
+            TvContext dbContext,
+            AddSongToCollection request) =>
+            dbContext.Collections
+                .Include(c => c.MediaItems)
+                .SelectOneAsync(c => c.Id, c => c.Id == request.CollectionId)
+                .Map(o => o.ToValidation<BaseError>("Collection does not exist."));
+
+        private static Task<Validation<BaseError, Song>> ValidateSong(
+            TvContext dbContext,
+            AddSongToCollection request) =>
+            dbContext.Songs
+                .SelectOneAsync(m => m.Id, e => e.Id == request.SongId)
+                .Map(o => o.ToValidation<BaseError>("Song does not exist"));
+
+        private record Parameters(Collection Collection, Song Song);
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/AddTraktList.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddTraktList.cs
@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record AddTraktList(string TraktListUrl) : IRequest<Either<BaseError, Unit>>, IBackgroundServiceRequest;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/AddTraktListHandler.cs
@@ -0,0 +1,80 @@
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Trakt;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class AddTraktListHandler : TraktCommandBase, IRequestHandler<AddTraktList, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IEntityLocker _entityLocker;
+
+        public AddTraktListHandler(
+            ITraktApiClient traktApiClient,
+            ISearchRepository searchRepository,
+            ISearchIndex searchIndex,
+            IDbContextFactory<TvContext> dbContextFactory,
+            ILogger<AddTraktListHandler> logger,
+            IEntityLocker entityLocker)
+            : base(traktApiClient, searchRepository, searchIndex, logger)
+        {
+            _dbContextFactory = dbContextFactory;
+            _entityLocker = entityLocker;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(AddTraktList request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                Validation<BaseError, Parameters> validation = ValidateUrl(request);
+                return await validation.Match(
+                    DoAdd,
+                    error => Task.FromResult<Either<BaseError, Unit>>(error.Join()));
+            }
+            finally
+            {
+                _entityLocker.UnlockTrakt();
+            }
+        }
+        
+        private static Validation<BaseError, Parameters> ValidateUrl(AddTraktList request)
+        {
+            const string PATTERN = @"(?:https:\/\/trakt\.tv\/users\/)?([\w\-_]+)\/(?:lists\/)?([\w\-_]+)";
+            Match match = Regex.Match(request.TraktListUrl, PATTERN);
+            if (match.Success)
+            {
+                string user = match.Groups[1].Value;
+                string list = match.Groups[2].Value;
+                return new Parameters(user, list);
+            }
+
+            return BaseError.New("Invalid Trakt list url");
+        }
+
+        private async Task<Either<BaseError, Unit>> DoAdd(Parameters parameters)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            
+            return await TraktApiClient.GetUserList(parameters.User, parameters.List)
+                .BindT(list => SaveList(dbContext, list))
+                .BindT(list => SaveListItems(dbContext, list))
+                .BindT(list => MatchListItems(dbContext, list))
+                .MapT(_ => Unit.Default);
+            
+            // match list items (and update in search index)
+        }
+
+        private record Parameters(string User, string List);
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateCollectionHandler.cs
@@ -60,7 +60,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                .Bind(_ => createCollection.NotLongerThan(50)(c => c.Name));

            var result2 = Optional(createCollection.Name)
-                .Filter(name => !allNames.Contains(name))
+                .Where(name => !allNames.Contains(name))
                .ToValidation<BaseError>("Collection name must be unique");

            return (result1, result2).Apply((_, _) => createCollection.Name);
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateMultiCollectionHandler.cs
@@ -56,7 +56,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                name => new MultiCollection
                {
                    Name = name,
-                    MultiCollectionItems = request.Items.Map(
+                    MultiCollectionItems = request.Items.Bind(
                            i =>
                            {
                                if (i.CollectionId.HasValue)
@@ -70,12 +70,10 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                                        });
                                }

-                                return None;
+                                return Option<MultiCollectionItem>.None;
                            })
-                        .Sequence()
-                        .Flatten()
                        .ToList(),
-                    MultiCollectionSmartItems = request.Items.Map(
+                    MultiCollectionSmartItems = request.Items.Bind(
                            i =>
                            {
                                if (i.SmartCollectionId.HasValue)
@@ -89,10 +87,8 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                                        });
                                }

-                                return None;
+                                return Option<MultiCollectionSmartItem>.None;
                            })
-                        .Sequence()
-                        .Flatten()
                        .ToList()
                });

@@ -108,7 +104,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                .Bind(_ => createMultiCollection.NotLongerThan(50)(c => c.Name));

            var result2 = Optional(createMultiCollection.Name)
-                .Filter(name => !allNames.Contains(name))
+                .Where(name => !allNames.Contains(name))
                .ToValidation<BaseError>("MultiCollection name must be unique");

            return (result1, result2).Apply((_, _) => createMultiCollection.Name);
--- a/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/CreateSmartCollectionHandler.cs
@@ -61,7 +61,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                .Bind(_ => createSmartCollection.NotLongerThan(50)(c => c.Name));

            var result2 = Optional(createSmartCollection.Name)
-                .Filter(name => !allNames.Contains(name))
+                .Where(name => !allNames.Contains(name))
                .ToValidation<BaseError>("SmartCollection name must be unique");

            return (result1, result2).Apply((_, _) => createSmartCollection.Name);
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktList.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktList.cs
@@ -0,0 +1,9 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record DeleteTraktList(int TraktListId) : IRequest<Either<BaseError, LanguageExt.Unit>>,
+        IBackgroundServiceRequest;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/DeleteTraktListHandler.cs
@@ -0,0 +1,79 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Trakt;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class DeleteTraktListHandler : TraktCommandBase, MediatR.IRequestHandler<DeleteTraktList, Either<BaseError, Unit>>
+    {
+        private readonly ISearchRepository _searchRepository;
+        private readonly ISearchIndex _searchIndex;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IEntityLocker _entityLocker;
+
+        public DeleteTraktListHandler(
+            ITraktApiClient traktApiClient,
+            ISearchRepository searchRepository,
+            ISearchIndex searchIndex,
+            IDbContextFactory<TvContext> dbContextFactory,
+            ILogger<DeleteTraktListHandler> logger,
+            IEntityLocker entityLocker)
+            : base(traktApiClient, searchRepository, searchIndex, logger)
+        {
+            _searchRepository = searchRepository;
+            _searchIndex = searchIndex;
+            _dbContextFactory = dbContextFactory;
+            _entityLocker = entityLocker;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            DeleteTraktList request,
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+
+                Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
+                return await validation.Apply(c => DoDeletion(dbContext, c));
+            }
+            finally
+            {
+                _entityLocker.UnlockTrakt();
+            }
+        }
+
+        private async Task<Unit> DoDeletion(TvContext dbContext, TraktList traktList)
+        {
+            var mediaItemIds = traktList.Items.Bind(i => Optional(i.MediaItemId)).ToList();
+
+            dbContext.TraktLists.Remove(traktList);
+            if (await dbContext.SaveChangesAsync() > 0)
+            {
+                foreach (int mediaItemId in mediaItemIds)
+                {
+                    foreach (MediaItem mediaItem in await _searchRepository.GetItemToIndex(mediaItemId))
+                    {
+                        await _searchIndex.UpdateItems(_searchRepository, new[] { mediaItem }.ToList());
+                    }
+                }
+            }
+
+            _searchIndex.Commit();
+
+            return Unit.Default;
+        }
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItems.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItems.cs
@@ -0,0 +1,10 @@
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public record MatchTraktListItems(int TraktListId, bool Unlock = true) : IRequest<Either<BaseError, Unit>>,
+        IBackgroundServiceRequest;
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/MatchTraktListItemsHandler.cs
@@ -0,0 +1,58 @@
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Locking;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Trakt;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Unit = LanguageExt.Unit;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public class MatchTraktListItemsHandler : TraktCommandBase,
+        IRequestHandler<MatchTraktListItems, Either<BaseError, Unit>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+        private readonly IEntityLocker _entityLocker;
+
+        public MatchTraktListItemsHandler(
+            ITraktApiClient traktApiClient,
+            ISearchRepository searchRepository,
+            ISearchIndex searchIndex,
+            IDbContextFactory<TvContext> dbContextFactory,
+            ILogger<MatchTraktListItemsHandler> logger,
+            IEntityLocker entityLocker) : base(traktApiClient, searchRepository, searchIndex, logger)
+        {
+            _dbContextFactory = dbContextFactory;
+            _entityLocker = entityLocker;
+        }
+
+        public async Task<Either<BaseError, Unit>> Handle(
+            MatchTraktListItems request,
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+                Validation<BaseError, TraktList> validation = await TraktListMustExist(dbContext, request.TraktListId);
+                return await validation.Match(
+                    async l => await MatchListItems(dbContext, l).MapT(_ => Unit.Default),
+                    error => Task.FromResult<Either<BaseError, Unit>>(error.Join()));
+            }
+            finally
+            {
+                if (request.Unlock)
+                {
+                    _entityLocker.UnlockTrakt();
+                }
+            }
+        }
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/TraktCommandBase.cs
@@ -0,0 +1,349 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Interfaces.Search;
+using ErsatzTV.Core.Interfaces.Trakt;
+using ErsatzTV.Core.Trakt;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.MediaCollections.Commands
+{
+    public abstract class TraktCommandBase
+    {
+        private readonly ISearchRepository _searchRepository;
+        private readonly ISearchIndex _searchIndex;
+        private readonly ILogger _logger;
+
+        protected TraktCommandBase(
+            ITraktApiClient traktApiClient,
+            ISearchRepository searchRepository,
+            ISearchIndex searchIndex,
+            ILogger logger)
+        {
+            _searchRepository = searchRepository;
+            _searchIndex = searchIndex;
+            _logger = logger;
+            TraktApiClient = traktApiClient;
+        }
+
+        protected ITraktApiClient TraktApiClient { get; }
+
+        protected static Task<Validation<BaseError, TraktList>>
+            TraktListMustExist(TvContext dbContext, int traktListId) =>
+            dbContext.TraktLists
+                .Include(l => l.Items)
+                .ThenInclude(i => i.Guids)
+                .SelectOneAsync(c => c.Id, c => c.Id == traktListId)
+                .Map(o => o.ToValidation<BaseError>($"TraktList {traktListId} does not exist."));
+
+        protected async Task<Either<BaseError, TraktList>> SaveList(TvContext dbContext, TraktList list)
+        {
+            Option<TraktList> maybeExisting = await dbContext.TraktLists
+                .Include(l => l.Items)
+                .ThenInclude(i => i.Guids)
+                .SelectOneAsync(tl => tl.Id, tl => tl.User == list.User && tl.List == list.List);
+
+            return await maybeExisting.Match(
+                async existing =>
+                {
+                    existing.Name = list.Name;
+                    existing.Description = list.Description;
+                    existing.ItemCount = list.ItemCount;
+
+                    await dbContext.SaveChangesAsync();
+
+                    return existing;
+                },
+                async () =>
+                {
+                    await dbContext.TraktLists.AddAsync(list);
+                    await dbContext.SaveChangesAsync();
+
+                    return list;
+                });
+        }
+
+        protected async Task<Either<BaseError, TraktList>> SaveListItems(TvContext dbContext, TraktList list)
+        {
+            Either<BaseError, List<TraktListItemWithGuids>> maybeItems =
+                await TraktApiClient.GetUserListItems(list.User, list.List);
+
+            return await maybeItems.Match<Task<Either<BaseError, TraktList>>>(
+                async items =>
+                {
+                    var toAdd = items.Filter(i => list.Items.All(i2 => i2.TraktId != i.TraktId)).ToList();
+                    var toRemove = list.Items.Filter(i => items.All(i2 => i2.TraktId != i.TraktId)).ToList();
+                    var toUpdate = list.Items.Filter(i => !toRemove.Contains(i)).ToList();
+                    
+                    list.Items.RemoveAll(toRemove.Contains);
+                    list.Items.AddRange(toAdd.Map(a => ProjectItem(list, a)));
+
+                    foreach (TraktListItem existing in toUpdate)
+                    {
+                        Option<TraktListItem> maybeIncoming = list.Items.Find(i => i.TraktId == existing.TraktId);
+                        foreach (TraktListItem incoming in maybeIncoming)
+                        {
+                            existing.Kind = incoming.Kind;
+                            existing.Rank = incoming.Rank;
+                            existing.Title = incoming.Title;
+                            existing.Year = incoming.Year;
+                            existing.Season = incoming.Season;
+                            existing.Episode = incoming.Episode;
+                            existing.Guids.Clear();
+                            existing.Guids.AddRange(incoming.Guids);
+                            existing.MediaItemId = null;
+                            existing.MediaItem = null;
+                        }
+                    }
+
+                    await dbContext.SaveChangesAsync();
+
+                    return list;
+                },
+                error => Task.FromResult(Left<BaseError, TraktList>(error)));
+        }
+
+        protected async Task<Either<BaseError, TraktList>> MatchListItems(TvContext dbContext, TraktList list)
+        {
+            try
+            {
+                var ids = new System.Collections.Generic.HashSet<int>();
+
+                foreach (TraktListItem item in list.Items
+                    .OrderBy(i => i.Title).ThenBy(i => i.Year).ThenBy(i => i.Season).ThenBy(i => i.Episode))
+                {
+                    switch (item.Kind)
+                    {
+                        case TraktListItemKind.Movie:
+                            Option<int> maybeMovieId = await IdentifyMovie(dbContext, item);
+                            foreach (int movieId in maybeMovieId)
+                            {
+                                ids.Add(movieId);
+                                item.MediaItemId = movieId;
+                            }
+
+                            break;
+                        case TraktListItemKind.Show:
+                            Option<int> maybeShowId = await IdentifyShow(dbContext, item);
+                            foreach (int showId in maybeShowId)
+                            {
+                                ids.Add(showId);
+                                item.MediaItemId = showId;
+                            }
+
+                            break;
+                        case TraktListItemKind.Season:
+                            Option<int> maybeSeasonId = await IdentifySeason(dbContext, item);
+                            foreach (int seasonId in maybeSeasonId)
+                            {
+                                ids.Add(seasonId);
+                                item.MediaItemId = seasonId;
+                            }
+
+                            break;
+                        default:
+                            Option<int> maybeEpisodeId = await IdentifyEpisode(dbContext, item);
+                            foreach (int episodeId in maybeEpisodeId)
+                            {
+                                ids.Add(episodeId);
+                                item.MediaItemId = episodeId;
+                            }
+
+                            break;
+                    }
+                }
+
+                await dbContext.SaveChangesAsync();
+
+                foreach (int mediaItemId in ids)
+                {
+                    Option<MediaItem> maybeItem = await _searchRepository.GetItemToIndex(mediaItemId);
+                    foreach (MediaItem item in maybeItem)
+                    {
+                        await _searchIndex.UpdateItems(_searchRepository, new[] { item }.ToList());
+                    }
+                }
+
+                _searchIndex.Commit();
+
+                return list;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error matching trakt list items");
+                return BaseError.New(ex.Message);
+            }
+        }
+
+        private static TraktListItem ProjectItem(TraktList list, TraktListItemWithGuids item)
+        {
+            var result = new TraktListItem
+            {
+                TraktList = list,
+                Kind = item.Kind,
+                TraktId = item.TraktId,
+                Rank = item.Rank,
+                Title = item.Title,
+                Year = item.Year,
+                Season = item.Season,
+                Episode = item.Episode,
+            };
+
+            result.Guids = item.Guids.Map(g => new TraktListItemGuid { Guid = g, TraktListItem = result }).ToList();
+
+            return result;
+        }
+        
+        private async Task<Option<int>> IdentifyMovie(TvContext dbContext, TraktListItem item)
+        {
+            var guids = item.Guids.Map(g => g.Guid).ToList();
+            
+            Option<int> maybeMovieByGuid = await dbContext.MovieMetadata
+                .AsNoTracking()
+                .Filter(mm => mm.Guids.Any(g => guids.Contains(g.Guid)))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(mm => mm.MovieId);
+
+            foreach (int movieId in maybeMovieByGuid)
+            {
+                _logger.LogDebug("Located trakt movie {Title} by id", item.DisplayTitle);
+                return movieId;
+            }
+
+            Option<int> maybeMovieByTitleYear = await dbContext.MovieMetadata
+                .AsNoTracking()
+                .Filter(mm => mm.Title == item.Title && mm.Year == item.Year)
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(mm => mm.MovieId);
+
+            foreach (int movieId in maybeMovieByTitleYear)
+            {
+                _logger.LogDebug("Located trakt movie {Title} by title/year", item.DisplayTitle);
+                return movieId;
+            }
+
+            _logger.LogDebug("Unable to locate trakt movie {Title}", item.DisplayTitle);
+
+            return None;
+        }
+
+        private async Task<Option<int>> IdentifyShow(TvContext dbContext, TraktListItem item)
+        {
+            var guids = item.Guids.Map(g => g.Guid).ToList();
+
+            Option<int> maybeShowByGuid = await dbContext.ShowMetadata
+                .AsNoTracking()
+                .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.ShowId);
+
+            foreach (int showId in maybeShowByGuid)
+            {
+                _logger.LogDebug("Located trakt show {Title} by id", item.DisplayTitle);
+                return showId;
+            }
+
+            Option<int> maybeShowByTitleYear = await dbContext.ShowMetadata
+                .AsNoTracking()
+                .Filter(sm => sm.Title == item.Title && sm.Year == item.Year)
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.ShowId);
+
+            foreach (int showId in maybeShowByTitleYear)
+            {
+                _logger.LogDebug("Located trakt show {Title} by title/year", item.Title);
+                return showId;
+            }
+
+            _logger.LogDebug("Unable to locate trakt show {Title}", item.DisplayTitle);
+
+            return None;
+        }
+        
+        private async Task<Option<int>> IdentifySeason(TvContext dbContext, TraktListItem item)
+        {
+            var guids = item.Guids.Map(g => g.Guid).ToList();
+
+            Option<int> maybeSeasonByGuid = await dbContext.SeasonMetadata
+                .AsNoTracking()
+                .Filter(sm => sm.Guids.Any(g => guids.Contains(g.Guid)))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.SeasonId);
+
+            foreach (int seasonId in maybeSeasonByGuid)
+            {
+                _logger.LogDebug("Located trakt season {Title} by id", item.DisplayTitle);
+                return seasonId;
+            }
+
+            Option<int> maybeSeasonByTitleYear = await dbContext.SeasonMetadata
+                .AsNoTracking()
+                .Filter(sm => sm.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
+                .Filter(sm => sm.Season.SeasonNumber == item.Season)
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.SeasonId);
+
+            foreach (int seasonId in maybeSeasonByTitleYear)
+            {
+                _logger.LogDebug("Located trakt season {Title} by title/year/season", item.DisplayTitle);
+                return seasonId;
+            }
+
+            _logger.LogDebug("Unable to locate trakt season {Title}", item.DisplayTitle);
+
+            return None;
+        }
+        
+        private async Task<Option<int>> IdentifyEpisode(TvContext dbContext, TraktListItem item)
+        {
+            var guids = item.Guids.Map(g => g.Guid).ToList();
+
+            Option<int> maybeEpisodeByGuid = await dbContext.EpisodeMetadata
+                .AsNoTracking()
+                .Filter(em => em.Guids.Any(g => guids.Contains(g.Guid)))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.EpisodeId);
+
+            foreach (int episodeId in maybeEpisodeByGuid)
+            {
+                _logger.LogDebug("Located trakt episode {Title} by id", item.DisplayTitle);
+                return episodeId;
+            }
+
+            Option<int> maybeEpisodeByTitleYear = await dbContext.EpisodeMetadata
+                .AsNoTracking()
+                .Filter(sm => sm.Episode.Season.Show.ShowMetadata.Any(s => s.Title == item.Title && s.Year == item.Year))
+                .Filter(em => em.Episode.Season.SeasonNumber == item.Season)
+                .Filter(sm => sm.Episode.EpisodeMetadata.Any(e => e.EpisodeNumber == item.Episode))
+                .FirstOrDefaultAsync()
+                .Map(Optional)
+                .MapT(sm => sm.EpisodeId);
+
+            foreach (int episodeId in maybeEpisodeByTitleYear)
+            {
+                _logger.LogDebug("Located trakt episode {Title} by title/year/season/episode", item.DisplayTitle);
+                return episodeId;
+            }
+
+            _logger.LogDebug("Unable to locate trakt episode {Title}", item.DisplayTitle);
+
+            return None;
+        }
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollectionHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Commands/UpdateMultiCollectionHandler.cs
@@ -156,7 +156,7 @@ namespace ErsatzTV.Application.MediaCollections.Commands
                .Bind(_ => updateMultiCollection.NotLongerThan(50)(c => c.Name));

            var result2 = Optional(updateMultiCollection.Name)
-                .Filter(name => !allNames.Contains(name))
+                .Where(name => !allNames.Contains(name))
                .ToValidation<BaseError>("MultiCollection name must be unique");

            return (result1, result2).Apply((_, _) => updateMultiCollection.Name);
--- a/ErsatzTV.Application/MediaCollections/Mapper.cs
+++ b/ErsatzTV.Application/MediaCollections/Mapper.cs
@@ -19,6 +19,15 @@ namespace ErsatzTV.Application.MediaCollections
        internal static SmartCollectionViewModel ProjectToViewModel(SmartCollection collection) =>
            new(collection.Id, collection.Name, collection.Query);

+        internal static TraktListViewModel ProjectToViewModel(TraktList traktList) =>
+            new(
+                traktList.Id,
+                traktList.TraktId,
+                $"{traktList.User}/{traktList.List}",
+                traktList.Name,
+                traktList.ItemCount,
+                traktList.Items.Count(i => i.MediaItemId.HasValue));
+
        private static MultiCollectionItemViewModel ProjectToViewModel(MultiCollectionItem multiCollectionItem) =>
            new(
                multiCollectionItem.MultiCollectionId,
--- a/ErsatzTV.Application/MediaCollections/PagedTraktListsViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/PagedTraktListsViewModel.cs
@@ -0,0 +1,6 @@
+using System.Collections.Generic;
+
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record PagedTraktListsViewModel(int TotalCount, List<TraktListViewModel> Page);
+}
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktLists.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktLists.cs
@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public record GetPagedTraktLists(int PageNum, int PageSize) : IRequest<PagedTraktListsViewModel>;
+}
--- a/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktListsHandler.cs
+++ b/ErsatzTV.Application/MediaCollections/Queries/GetPagedTraktListsHandler.cs
@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using ErsatzTV.Infrastructure.Data;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.MediaCollections.Mapper;
+
+namespace ErsatzTV.Application.MediaCollections.Queries
+{
+    public class GetPagedTraktListsHandler : IRequestHandler<GetPagedTraktLists, PagedTraktListsViewModel>
+    {
+        private readonly IDbConnection _dbConnection;
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public GetPagedTraktListsHandler(IDbContextFactory<TvContext> dbContextFactory, IDbConnection dbConnection)
+        {
+            _dbContextFactory = dbContextFactory;
+            _dbConnection = dbConnection;
+        }
+
+        public async Task<PagedTraktListsViewModel> Handle(
+            GetPagedTraktLists request,
+            CancellationToken cancellationToken)
+        {
+            int count = await _dbConnection.QuerySingleAsync<int>(@"SELECT COUNT (*) FROM TraktList");
+
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            List<TraktListViewModel> page = await dbContext.TraktLists.FromSqlRaw(
+                    @"SELECT * FROM TraktList
+                    ORDER BY Name
+                    COLLATE NOCASE
+                    LIMIT {0} OFFSET {1}",
+                    request.PageSize,
+                    request.PageNum * request.PageSize)
+                .Include(l => l.Items)
+                .ToListAsync(cancellationToken)
+                .Map(list => list.Map(ProjectToViewModel).ToList());
+
+            return new PagedTraktListsViewModel(count, page);
+        }
+    }
+}
--- a/ErsatzTV.Application/MediaCollections/TraktListViewModel.cs
+++ b/ErsatzTV.Application/MediaCollections/TraktListViewModel.cs
@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.MediaCollections
+{
+    public record TraktListViewModel(int Id, int TraktId, string Slug, string Name, int ItemCount, int MatchCount);
+}
--- a/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
+++ b/ErsatzTV.Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
@@ -26,6 +26,8 @@ namespace ErsatzTV.Application.MediaSources.Commands
        private readonly IMediator _mediator;
        private readonly IMovieFolderScanner _movieFolderScanner;
        private readonly IMusicVideoFolderScanner _musicVideoFolderScanner;
+        private readonly IOtherVideoFolderScanner _otherVideoFolderScanner;
+        private readonly ISongFolderScanner _songFolderScanner;
        private readonly ITelevisionFolderScanner _televisionFolderScanner;

        public ScanLocalLibraryHandler(
@@ -34,6 +36,8 @@ namespace ErsatzTV.Application.MediaSources.Commands
            IMovieFolderScanner movieFolderScanner,
            ITelevisionFolderScanner televisionFolderScanner,
            IMusicVideoFolderScanner musicVideoFolderScanner,
+            IOtherVideoFolderScanner otherVideoFolderScanner,
+            ISongFolderScanner songFolderScanner,
            IEntityLocker entityLocker,
            IMediator mediator,
            ILogger<ScanLocalLibraryHandler> logger)
@@ -43,6 +47,8 @@ namespace ErsatzTV.Application.MediaSources.Commands
            _movieFolderScanner = movieFolderScanner;
            _televisionFolderScanner = televisionFolderScanner;
            _musicVideoFolderScanner = musicVideoFolderScanner;
+            _otherVideoFolderScanner = otherVideoFolderScanner;
+            _songFolderScanner = songFolderScanner;
            _entityLocker = entityLocker;
            _mediator = mediator;
            _logger = logger;
@@ -64,7 +70,8 @@ namespace ErsatzTV.Application.MediaSources.Commands

        private async Task<Unit> PerformScan(RequestParameters parameters)
        {
-            (LocalLibrary localLibrary, string ffprobePath, bool forceScan, int libraryRefreshInterval) = parameters;
+            (LocalLibrary localLibrary, string ffprobePath, string ffmpegPath, bool forceScan,
+                int libraryRefreshInterval) = parameters;

            var sw = new Stopwatch();
            sw.Start();
@@ -78,7 +85,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
                decimal progressMin = (decimal) i / localLibrary.Paths.Count;
                decimal progressMax = (decimal) (i + 1) / localLibrary.Paths.Count;

-                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+                var lastScan = new DateTimeOffset(libraryPath.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
                DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(libraryRefreshInterval);
                if (forceScan || nextScan < DateTimeOffset.Now)
                {
@@ -107,6 +114,21 @@ namespace ErsatzTV.Application.MediaSources.Commands
                                progressMin,
                                progressMax);
                            break;
+                        case LibraryMediaKind.OtherVideos:
+                            await _otherVideoFolderScanner.ScanFolder(
+                                libraryPath,
+                                ffprobePath,
+                                progressMin,
+                                progressMax);
+                            break;
+                        case LibraryMediaKind.Songs:
+                            await _songFolderScanner.ScanFolder(
+                                libraryPath,
+                                ffprobePath,
+                                ffmpegPath,
+                                progressMin,
+                                progressMax);
+                            break;
                    }

                    libraryPath.LastScan = DateTime.UtcNow;
@@ -139,11 +161,12 @@ namespace ErsatzTV.Application.MediaSources.Commands
        }

        private async Task<Validation<BaseError, RequestParameters>> Validate(IScanLocalLibrary request) =>
-            (await LocalLibraryMustExist(request), await ValidateFFprobePath(), await ValidateLibraryRefreshInterval())
+            (await LocalLibraryMustExist(request), await ValidateFFprobePath(), await ValidateFFmpegPath(), await ValidateLibraryRefreshInterval())
            .Apply(
-                (library, ffprobePath, libraryRefreshInterval) => new RequestParameters(
+                (library, ffprobePath, ffmpegPath, libraryRefreshInterval) => new RequestParameters(
                    library,
                    ffprobePath,
+                    ffmpegPath,
                    request.ForceScan,
                    libraryRefreshInterval));

@@ -160,6 +183,13 @@ namespace ErsatzTV.Application.MediaSources.Commands
                    ffprobePath =>
                        ffprobePath.ToValidation<BaseError>("FFprobe path does not exist on the file system"));

+        private Task<Validation<BaseError, string>> ValidateFFmpegPath() =>
+            _configElementRepository.GetValue<string>(ConfigElementKey.FFmpegPath)
+                .FilterT(File.Exists)
+                .Map(
+                    ffmpegPath =>
+                        ffmpegPath.ToValidation<BaseError>("FFmpeg path does not exist on the file system"));
+
        private Task<Validation<BaseError, int>> ValidateLibraryRefreshInterval() =>
            _configElementRepository.GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
                .FilterT(lri => lri > 0)
@@ -168,6 +198,7 @@ namespace ErsatzTV.Application.MediaSources.Commands
        private record RequestParameters(
            LocalLibrary LocalLibrary,
            string FFprobePath,
+            string FFmpegPath,
            bool ForceScan,
            int LibraryRefreshInterval);
    }
--- a/ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs
+++ b/ErsatzTV.Application/Playouts/Commands/BuildPlayoutHandler.cs
@@ -52,6 +52,21 @@ namespace ErsatzTV.Application.Playouts.Commands
                .Include(p => p.ProgramSchedule)
                .ThenInclude(ps => ps.Items)
                .ThenInclude(psi => psi.MediaItem)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.PreRollFiller)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.MidRollFiller)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.PostRollFiller)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.TailFiller)
+                .Include(p => p.ProgramSchedule)
+                .ThenInclude(ps => ps.Items)
+                .ThenInclude(psi => psi.FallbackFiller)
                .SelectOneAsync(p => p.Id, p => p.Id == buildPlayout.PlayoutId)
                .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
    }
--- a/ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs
+++ b/ErsatzTV.Application/Playouts/Commands/UpdatePlayout.cs
@@ -0,0 +1,10 @@
+using System;
+using ErsatzTV.Core;
+using LanguageExt;
+using MediatR;
+
+namespace ErsatzTV.Application.Playouts.Commands
+{
+    public record UpdatePlayout
+        (int PlayoutId, Option<TimeSpan> DailyRebuildTime) : IRequest<Either<BaseError, PlayoutNameViewModel>>;
+}
--- a/ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs
+++ b/ErsatzTV.Application/Playouts/Commands/UpdatePlayoutHandler.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using LanguageExt;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Application.Playouts.Commands
+{
+    public class UpdatePlayoutHandler : IRequestHandler<UpdatePlayout, Either<BaseError, PlayoutNameViewModel>>
+    {
+        private readonly IDbContextFactory<TvContext> _dbContextFactory;
+
+        public UpdatePlayoutHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+            _dbContextFactory = dbContextFactory;
+
+        public async Task<Either<BaseError, PlayoutNameViewModel>> Handle(
+            UpdatePlayout request,
+            CancellationToken cancellationToken)
+        {
+            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            Validation<BaseError, Playout> validation = await Validate(dbContext, request);
+            return await validation.Apply(playout => ApplyUpdateRequest(dbContext, request, playout));
+        }
+
+        private static async Task<PlayoutNameViewModel> ApplyUpdateRequest(
+            TvContext dbContext,
+            UpdatePlayout request,
+            Playout playout)
+        {
+            playout.DailyRebuildTime = null;
+
+            foreach (TimeSpan dailyRebuildTime in request.DailyRebuildTime)
+            {
+                playout.DailyRebuildTime = dailyRebuildTime;
+            }
+
+            await dbContext.SaveChangesAsync();
+
+            return new PlayoutNameViewModel(
+                playout.Id,
+                playout.Channel.Name,
+                playout.Channel.Number,
+                playout.ProgramSchedule.Name,
+                Optional(playout.DailyRebuildTime));
+        }
+
+        private static Task<Validation<BaseError, Playout>> Validate(TvContext dbContext, UpdatePlayout request) =>
+            PlayoutMustExist(dbContext, request);
+
+        private static Task<Validation<BaseError, Playout>> PlayoutMustExist(
+            TvContext dbContext,
+            UpdatePlayout updatePlayout) =>
+            dbContext.Playouts
+                .Include(p => p.Channel)
+                .Include(p => p.ProgramSchedule)
+                .SelectOneAsync(p => p.Id, p => p.Id == updatePlayout.PlayoutId)
+                .Map(o => o.ToValidation<BaseError>("Playout does not exist."));
+    }
+}
--- a/ErsatzTV.Application/Playouts/Mapper.cs
+++ b/ErsatzTV.Application/Playouts/Mapper.cs
@@ -8,13 +8,13 @@ namespace ErsatzTV.Application.Playouts
    {
        internal static PlayoutItemViewModel ProjectToViewModel(PlayoutItem playoutItem) =>
            new(
-                GetDisplayTitle(playoutItem.MediaItem),
+                GetDisplayTitle(playoutItem),
                playoutItem.StartOffset,
-                GetDisplayDuration(playoutItem.MediaItem));
+                GetDisplayDuration(playoutItem.FinishOffset - playoutItem.StartOffset));

-        private static string GetDisplayTitle(MediaItem mediaItem)
+        private static string GetDisplayTitle(PlayoutItem playoutItem)
        {
-            switch (mediaItem)
+            switch (playoutItem.MediaItem)
            {
                case Episode e:
                    string showTitle = e.Season.Show.ShowMetadata.HeadOrNone()
@@ -28,6 +28,11 @@ namespace ErsatzTV.Application.Playouts

                    var numbersString = $"e{string.Join('e', episodeNumbers.Map(n => $"{n:00}"))}";
                    var titlesString = $"{string.Join('/', episodeTitles)}";
+                    if (!string.IsNullOrWhiteSpace(playoutItem.ChapterTitle))
+                    {
+                        titlesString += $" ({playoutItem.ChapterTitle})";
+                    }
+
                    return $"{showTitle}s{e.Season.SeasonNumber:00}{numbersString} - {titlesString}";
                case Movie m:
                    return m.MovieMetadata.HeadOrNone().Map(mm => mm.Title).IfNone("[unknown movie]");
@@ -36,25 +41,29 @@ namespace ErsatzTV.Application.Playouts
                        .Map(am => $"{am.Title} - ").IfNone(string.Empty);
                    return mv.MusicVideoMetadata.HeadOrNone()
                        .Map(mvm => $"{artistName}{mvm.Title}")
+                        .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
                        .IfNone("[unknown music video]");
+                case OtherVideo ov:
+                    return ov.OtherVideoMetadata.HeadOrNone()
+                        .Map(ovm => ovm.Title ?? string.Empty)
+                        .Map(s => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? s : $"{s} ({playoutItem.ChapterTitle})")
+                        .IfNone("[unknown video]");
+                case Song s:
+                    string songArtist = s.SongMetadata.HeadOrNone()
+                        .Map(sm => string.IsNullOrWhiteSpace(sm.Artist) ? string.Empty : $"{sm.Artist} - ")
+                        .IfNone(string.Empty);
+                    return s.SongMetadata.HeadOrNone()
+                        .Map(sm => $"{songArtist}{sm.Title ?? string.Empty}")
+                        .Map(t => string.IsNullOrWhiteSpace(playoutItem.ChapterTitle) ? t : $"{s} ({playoutItem.ChapterTitle})")
+                        .IfNone("[unknown song]");
                default:
                    return string.Empty;
            }
        }

-        private static string GetDisplayDuration(MediaItem mediaItem)
-        {
-            MediaVersion version = mediaItem switch
-            {
-                Movie m => m.MediaVersions.Head(),
-                Episode e => e.MediaVersions.Head(),
-                MusicVideo mv => mv.MediaVersions.Head(),
-                _ => throw new ArgumentOutOfRangeException(nameof(mediaItem))
-            };
-
-            return string.Format(
-                version.Duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
-                version.Duration);
-        }
+        private static string GetDisplayDuration(TimeSpan duration) =>
+            string.Format(
+                duration.TotalHours >= 1 ? @"{0:h\:mm\:ss}" : @"{0:mm\:ss}",
+                duration);
    }
 }
--- a/ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs
+++ b/ErsatzTV.Application/Playouts/PlayoutNameViewModel.cs
@@ -1,8 +1,12 @@
-namespace ErsatzTV.Application.Playouts
+using System;
+using LanguageExt;
+
+namespace ErsatzTV.Application.Playouts
 {
    public record PlayoutNameViewModel(
        int PlayoutId,
        string ChannelName,
        string ChannelNumber,
-        string ScheduleName);
+        string ScheduleName,
+        Option<TimeSpan> DailyRebuildTime);
 }
--- a/ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetAllPlayoutsHandler.cs
@@ -4,6 +4,7 @@ using System.Threading.Tasks;
 using ErsatzTV.Infrastructure.Data;
 using MediatR;
 using Microsoft.EntityFrameworkCore;
+using static LanguageExt.Prelude;

 namespace ErsatzTV.Application.Playouts.Queries
 {
@@ -21,7 +22,13 @@ namespace ErsatzTV.Application.Playouts.Queries
            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
            return await dbContext.Playouts
                .Filter(p => p.Channel != null && p.ProgramSchedule != null)
-                .Map(p => new PlayoutNameViewModel(p.Id, p.Channel.Name, p.Channel.Number, p.ProgramSchedule.Name))
+                .Map(
+                    p => new PlayoutNameViewModel(
+                        p.Id,
+                        p.Channel.Name,
+                        p.Channel.Number,
+                        p.ProgramSchedule.Name,
+                        Optional(p.DailyRebuildTime)))
                .ToListAsync(cancellationToken);
        }
    }
--- a/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsById.cs
@@ -0,0 +1,6 @@
+using MediatR;
+
+namespace ErsatzTV.Application.Playouts.Queries
+{
+    public record GetFuturePlayoutItemsById(int PlayoutId, bool ShowFiller, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
+}
--- a/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetFuturePlayoutItemsByIdHandler.cs
@@ -1,8 +1,10 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Infrastructure.Data;
 using LanguageExt;
 using MediatR;
@@ -11,21 +13,23 @@ using static ErsatzTV.Application.Playouts.Mapper;

 namespace ErsatzTV.Application.Playouts.Queries
 {
-    public class GetPlayoutItemsByIdHandler : IRequestHandler<GetPlayoutItemsById, PagedPlayoutItemsViewModel>
+    public class GetFuturePlayoutItemsByIdHandler : IRequestHandler<GetFuturePlayoutItemsById, PagedPlayoutItemsViewModel>
    {
        private readonly IDbContextFactory<TvContext> _dbContextFactory;

-        public GetPlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
+        public GetFuturePlayoutItemsByIdHandler(IDbContextFactory<TvContext> dbContextFactory) =>
            _dbContextFactory = dbContextFactory;

        public async Task<PagedPlayoutItemsViewModel> Handle(
-            GetPlayoutItemsById request,
+            GetFuturePlayoutItemsById request,
            CancellationToken cancellationToken)
        {
-            await using TvContext dbContext = _dbContextFactory.CreateDbContext();
+            await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+            DateTime now = DateTimeOffset.Now.UtcDateTime;

            int totalCount = await dbContext.PlayoutItems
-                .CountAsync(i => i.PlayoutId == request.PlayoutId, cancellationToken);
+                .CountAsync(i => i.Finish >= now && i.PlayoutId == request.PlayoutId && (request.ShowFiller || i.FillerKind == FillerKind.None), cancellationToken);
            
            List<PlayoutItemViewModel> page = await dbContext.PlayoutItems
                .Include(i => i.MediaItem)
@@ -49,7 +53,17 @@ namespace ErsatzTV.Application.Playouts.Queries
                .Include(i => i.MediaItem)
                .ThenInclude(mi => (mi as Episode).Season.Show)
                .ThenInclude(s => s.ShowMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).OtherVideoMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as OtherVideo).MediaVersions)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as Song).SongMetadata)
+                .Include(i => i.MediaItem)
+                .ThenInclude(mi => (mi as Song).MediaVersions)
                .Filter(i => i.PlayoutId == request.PlayoutId)
+                .Filter(i => i.Finish >= now)
+                .Filter(i => request.ShowFiller || i.FillerKind == FillerKind.None)
                .OrderBy(i => i.Start)
                .Skip(request.PageNum * request.PageSize)
                .Take(request.PageSize)
--- a/ErsatzTV.Application/Playouts/Queries/GetPlayoutItemsById.cs
+++ b/ErsatzTV.Application/Playouts/Queries/GetPlayoutItemsById.cs
@@ -1,7 +0,0 @@
-using System.Collections.Generic;
-using MediatR;
-
-namespace ErsatzTV.Application.Playouts.Queries
-{
-    public record GetPlayoutItemsById(int PlayoutId, int PageNum, int PageSize) : IRequest<PagedPlayoutItemsViewModel>;
-}
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexLibraryByIdHandler.cs
@@ -65,7 +65,7 @@ namespace ErsatzTV.Application.Plex.Commands

        private async Task<Unit> Synchronize(RequestParameters parameters)
        {
-            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? DateTime.MinValue, TimeSpan.Zero);
+            var lastScan = new DateTimeOffset(parameters.Library.LastScan ?? SystemTime.MinValueUtc, TimeSpan.Zero);
            DateTimeOffset nextScan = lastScan + TimeSpan.FromHours(parameters.LibraryRefreshInterval);
            if (parameters.ForceScan || nextScan < DateTimeOffset.Now)
            {
--- a/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs
+++ b/ErsatzTV.Application/Plex/Commands/SynchronizePlexMediaSourcesHandler.cs
@@ -8,6 +8,7 @@ using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Locking;
 using ErsatzTV.Core.Interfaces.Plex;
 using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Plex;
 using LanguageExt;
 using MediatR;
 using Microsoft.Extensions.Logging;
@@ -23,16 +24,22 @@ namespace ErsatzTV.Application.Plex.Commands
        private readonly ILogger<SynchronizePlexMediaSourcesHandler> _logger;
        private readonly IMediaSourceRepository _mediaSourceRepository;
        private readonly IPlexTvApiClient _plexTvApiClient;
+        private readonly IPlexServerApiClient _plexServerApiClient;
+        private readonly IPlexSecretStore _plexSecretStore;

        public SynchronizePlexMediaSourcesHandler(
            IMediaSourceRepository mediaSourceRepository,
            IPlexTvApiClient plexTvApiClient,
+            IPlexServerApiClient plexServerApiClient,
+            IPlexSecretStore plexSecretStore,
            ChannelWriter<IPlexBackgroundServiceRequest> channel,
            IEntityLocker entityLocker,
            ILogger<SynchronizePlexMediaSourcesHandler> logger)
        {
            _mediaSourceRepository = mediaSourceRepository;
            _plexTvApiClient = plexTvApiClient;
+            _plexServerApiClient = plexServerApiClient;
+            _plexSecretStore = plexSecretStore;
            _channel = channel;
            _entityLocker = entityLocker;
            _logger = logger;
@@ -69,32 +76,76 @@ namespace ErsatzTV.Application.Plex.Commands
            return allExisting;
        }

-        private Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
+        private async Task SynchronizeServer(List<PlexMediaSource> allExisting, PlexMediaSource server)
        {
            Option<PlexMediaSource> maybeExisting =
                allExisting.Find(s => s.ClientIdentifier == server.ClientIdentifier);
-            return maybeExisting.Match(
-                existing =>
-                {
-                    existing.Platform = server.Platform;
-                    existing.PlatformVersion = server.PlatformVersion;
-                    existing.ProductVersion = server.ProductVersion;
-                    existing.ServerName = server.ServerName;
-                    var toAdd = server.Connections
-                        .Filter(connection => existing.Connections.All(c => c.Uri != connection.Uri)).ToList();
-                    var toRemove = existing.Connections
-                        .Filter(connection => server.Connections.All(c => c.Uri != connection.Uri)).ToList();
-                    return _mediaSourceRepository.Update(existing, server.Connections, toAdd, toRemove);
-                },
-                async () =>
-                {
-                    if (server.Connections.Any())
-                    {
-                        server.Connections.Head().IsActive = true;
-                    }

-                    await _mediaSourceRepository.Add(server);
-                });
+            foreach (PlexMediaSource existing in maybeExisting)
+            {
+                existing.Platform = server.Platform;
+                existing.PlatformVersion = server.PlatformVersion;
+                existing.ProductVersion = server.ProductVersion;
+                existing.ServerName = server.ServerName;
+                var toAdd = server.Connections
+                    .Filter(connection => existing.Connections.All(c => c.Uri != connection.Uri)).ToList();
+                var toRemove = existing.Connections
+                    .Filter(connection => server.Connections.All(c => c.Uri != connection.Uri)).ToList();
+                await _mediaSourceRepository.Update(existing, toAdd, toRemove);
+                await FindConnectionToActivate(existing);
+            }
+
+            if (maybeExisting.IsNone)
+            {
+                await _mediaSourceRepository.Add(server);
+                await FindConnectionToActivate(server);
+            }
+        }
+
+        private async Task FindConnectionToActivate(PlexMediaSource server)
+        {
+            var prioritized = server.Connections.OrderBy(pc => pc.IsActive ? 0 : 1).ToList();
+            foreach (PlexConnection connection in server.Connections)
+            {
+                connection.IsActive = false;
+            }
+
+            Option<PlexServerAuthToken> maybeToken = await _plexSecretStore.GetServerAuthToken(server.ClientIdentifier);
+            foreach (PlexServerAuthToken token in maybeToken)
+            {
+                foreach (PlexConnection connection in prioritized)
+                {
+                    try
+                    {
+                        _logger.LogDebug("Attempting to locate to Plex at {Uri}", connection.Uri);
+                        if (await _plexServerApiClient.Ping(connection, token))
+                        {
+                            _logger.LogInformation("Located Plex at {Uri}", connection.Uri);
+                            connection.IsActive = true;
+                            break;
+                        }
+                    }
+                    catch
+                    {
+                        // do nothing
+                    }
+                }
+            }
+
+            if (maybeToken.IsNone)
+            {
+                _logger.LogError(
+                    "Unable to activate Plex connection for server {Server} without auth token",
+                    server.ServerName);
+            }
+
+            if (server.Connections.All(c => !c.IsActive))
+            {
+                _logger.LogError("Unable to locate Plex");
+                server.Connections.Head().IsActive = true;
+            }
+
+            await _mediaSourceRepository.Update(server, new List<PlexConnection>(), new List<PlexConnection>());
        }
    }
 }
--- a/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs
+++ b/ErsatzTV.Application/ProgramSchedules/Commands/AddProgramScheduleItem.cs
@@ -19,6 +19,12 @@ namespace ErsatzTV.Application.ProgramSchedules.Commands
        PlaybackOrder PlaybackOrder,
        int? MultipleCount,
        TimeSpan? PlayoutDuration,
-        bool? OfflineTail,
-        string CustomTitle) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
+        TailMode TailMode,
+        string CustomTitle,
+        GuideMode GuideMode,
+        int? PreRollFillerId,
+        int? MidRollFillerId,
+        int? PostRollFillerId,
+        int? TailFillerId,
+        int? FallbackFillerId) : IRequest<Either<BaseError, ProgramScheduleItemViewModel>>, IProgramScheduleItemRequest;
 }
--- a/Show More
+++ b/Show More